36fd113d01
I want this code to be run without having to install any libraries. The interpreter now runs in the console thanks to javidx9's olcGameEngine Enjoy this SFML-free version of the interpreter!
1511 lines
32 KiB
C++
1511 lines
32 KiB
C++
////////////////////////////////////////////////////////////////
|
|
// A CHIP-8 INTERPRETER, CONTAINED IN ONE FILE
|
|
//
|
|
// INTERPRETATION LOGIC DONE BY ME
|
|
//
|
|
// GRAPHICS HANDLING CODED BY JAVIDX9
|
|
// https://www.youtube.com/channel/UC-yuWVUplUJZvieEligKBkA
|
|
//
|
|
// I used the snippets I needed from his olcGameEngine.hpp
|
|
// I removed everything not needed to draw pixels to a console
|
|
//
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
#include <array>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <random>
|
|
#include <chrono>
|
|
#include <unordered_map>
|
|
#include <string>
|
|
|
|
#pragma comment(lib, "winmm.lib")
|
|
|
|
#ifndef UNICODE
|
|
#error Please enable UNICODE for your compiler! VS: Project Properties -> General -> \
|
|
Character Set -> Use Unicode. Thanks! - Javidx9
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
|
|
#include <atomic>
|
|
#include <condition_variable>
|
|
|
|
#define SUPPRESS_PROC_INFO
|
|
|
|
|
|
enum COLOUR
|
|
{
|
|
FG_BLACK = 0x0000,
|
|
FG_DARK_BLUE = 0x0001,
|
|
FG_DARK_GREEN = 0x0002,
|
|
FG_DARK_CYAN = 0x0003,
|
|
FG_DARK_RED = 0x0004,
|
|
FG_DARK_MAGENTA = 0x0005,
|
|
FG_DARK_YELLOW = 0x0006,
|
|
FG_GREY = 0x0007, // Thanks MS :-/
|
|
FG_DARK_GREY = 0x0008,
|
|
FG_BLUE = 0x0009,
|
|
FG_GREEN = 0x000A,
|
|
FG_CYAN = 0x000B,
|
|
FG_RED = 0x000C,
|
|
FG_MAGENTA = 0x000D,
|
|
FG_YELLOW = 0x000E,
|
|
FG_WHITE = 0x000F,
|
|
BG_BLACK = 0x0000,
|
|
BG_DARK_BLUE = 0x0010,
|
|
BG_DARK_GREEN = 0x0020,
|
|
BG_DARK_CYAN = 0x0030,
|
|
BG_DARK_RED = 0x0040,
|
|
BG_DARK_MAGENTA = 0x0050,
|
|
BG_DARK_YELLOW = 0x0060,
|
|
BG_GREY = 0x0070,
|
|
BG_DARK_GREY = 0x0080,
|
|
BG_BLUE = 0x0090,
|
|
BG_GREEN = 0x00A0,
|
|
BG_CYAN = 0x00B0,
|
|
BG_RED = 0x00C0,
|
|
BG_MAGENTA = 0x00D0,
|
|
BG_YELLOW = 0x00E0,
|
|
BG_WHITE = 0x00F0,
|
|
};
|
|
|
|
enum PIXEL_TYPE
|
|
{
|
|
PIXEL_SOLID = 0x2588,
|
|
PIXEL_THREEQUARTERS = 0x2593,
|
|
PIXEL_HALF = 0x2592,
|
|
PIXEL_QUARTER = 0x2591,
|
|
};
|
|
|
|
|
|
|
|
typedef unsigned short WORD;
|
|
typedef unsigned char BYTE;
|
|
|
|
const constexpr unsigned WIDTH = 64;
|
|
const constexpr unsigned HEIGHT = 32;
|
|
const constexpr unsigned RAM = 4096; // 4kB RAM
|
|
const constexpr unsigned FONTSET_SIZE = 16 * 5;
|
|
const constexpr unsigned SCALE = 20;
|
|
const constexpr char* FILENAME = "invaders.c8";
|
|
|
|
BYTE fontset[FONTSET_SIZE] =
|
|
{
|
|
0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
|
|
0x20, 0x60, 0x20, 0x20, 0x70, // 1
|
|
0xF0, 0x10, 0xF0, 0x80, 0xF0, // 2
|
|
0xF0, 0x10, 0xF0, 0x10, 0xF0, // 3
|
|
0x90, 0x90, 0xF0, 0x10, 0x10, // 4
|
|
0xF0, 0x80, 0xF0, 0x10, 0xF0, // 5
|
|
0xF0, 0x80, 0xF0, 0x90, 0xF0, // 6
|
|
0xF0, 0x10, 0x20, 0x40, 0x40, // 7
|
|
0xF0, 0x90, 0xF0, 0x90, 0xF0, // 8
|
|
0xF0, 0x90, 0xF0, 0x10, 0xF0, // 9
|
|
0xF0, 0x90, 0xF0, 0x90, 0x90, // A
|
|
0xE0, 0x90, 0xE0, 0x90, 0xE0, // B
|
|
0xF0, 0x80, 0x80, 0x80, 0xF0, // C
|
|
0xE0, 0x90, 0x90, 0x90, 0xE0, // D
|
|
0xF0, 0x80, 0xF0, 0x80, 0xF0, // E
|
|
0xF0, 0x80, 0xF0, 0x80, 0x80 // F
|
|
};
|
|
|
|
std::unordered_map<BYTE, int> keymap =
|
|
{
|
|
{ 0x1, '1' },{ 0x2, '2' },{ 0x3, '3' },{ 0xC, '4' },
|
|
{ 0x4, 'Q' },{ 0x5, 'W' },{ 0x6, 'E' },{ 0xD, 'R' },
|
|
{ 0x7, 'A' },{ 0x8, 'S' },{ 0x9, 'D' },{ 0xE, 'F' },
|
|
{ 0xA, 'Y' },{ 0x0, 'X' },{ 0xB, 'C' },{ 0xF, 'V' }
|
|
};
|
|
|
|
class Chip8
|
|
{
|
|
public:
|
|
|
|
bool interrupt;
|
|
bool drawFlag;
|
|
|
|
BYTE delay_timer;
|
|
BYTE sound_timer;
|
|
|
|
//////////////////////////////////////////////
|
|
/// \brief Intializes registers and memory
|
|
///
|
|
//////////////////////////////////////////////
|
|
void Initialize()
|
|
{
|
|
pc = 0x200; // Program counter starts at 0x200
|
|
opcode = 0; // Reset opcode
|
|
I = 0; // Reset index register
|
|
sp = 0; // Reset stack pointer
|
|
|
|
std::fill(std::begin(gfx), std::end(gfx), 0x00); // Clear display
|
|
std::fill(std::begin(stack), std::end(stack), 0x00); // Clear stack
|
|
std::fill(std::begin(memory), std::end(memory), 0x00); // Clear RAM
|
|
std::fill(std::begin(V), std::end(V), 0x00); // Clear Registers
|
|
|
|
for (int i = 0; i < FONTSET_SIZE; i++) // Load fontset
|
|
memory[i] = fontset[i];
|
|
|
|
interrupt = false;
|
|
drawFlag = false;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////
|
|
/// \brief Loads a ROM into memory
|
|
///
|
|
/// \param filepath The path to the ROM
|
|
//////////////////////////////////////////////
|
|
void LoadGame(std::string filepath)
|
|
{
|
|
// Open File
|
|
std::ifstream file(filepath, std::ios::binary);
|
|
|
|
// All bytes in the file will be stored at 0x200 in memory
|
|
int offset = 0;
|
|
while (file.good())
|
|
{
|
|
memory[0x200 + offset++] = (BYTE)file.get();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////
|
|
/// \brief Returns the current display
|
|
///
|
|
//////////////////////////////////////////////
|
|
BYTE* getDisplay() { return gfx; }
|
|
|
|
|
|
//////////////////////////////////////////////
|
|
/// \brief Goes through one emulation cycle
|
|
///
|
|
//////////////////////////////////////////////
|
|
void EmulateCycle()
|
|
{
|
|
// Fetch opcode
|
|
opcode = (memory[pc] << 8) | memory[pc + 1];
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << std::uppercase << std::hex << opcode << ": ";
|
|
#endif
|
|
|
|
BYTE x = (opcode & 0x0F00) >> 8;
|
|
BYTE y = (opcode & 0x00F0) >> 4;
|
|
BYTE n = (opcode & 0x000F);
|
|
BYTE kk = (opcode & 0x00FF);
|
|
WORD nnn = (opcode & 0x0FFF);
|
|
|
|
// Decode opcode
|
|
// Execute opcode
|
|
|
|
switch (opcode & 0xF000)
|
|
{
|
|
case 0x0000: // Multi case opcode
|
|
switch (opcode & 0x00FF)
|
|
{
|
|
case 0xE0: // Clear display
|
|
CLS();
|
|
break;
|
|
|
|
case 0xEE: // Return from subroutine
|
|
RET();
|
|
break;
|
|
|
|
default:
|
|
std::cerr << "Unknown OpCode" << std::endl;
|
|
interrupt = true;
|
|
//interrupt = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case 0x1000: // 1NNN: Set Program counter to NNN
|
|
JP(nnn);
|
|
break;
|
|
|
|
|
|
case 0x2000: // 2NNN: Calls subroutine at NNN
|
|
CALL(nnn);
|
|
break;
|
|
|
|
|
|
case 0x3000: // 3XKK: If VX == KK, skip next instruction
|
|
SE(x, kk);
|
|
break;
|
|
|
|
|
|
case 0x4000: // 4XKK: If VX != KK, skip next instruction
|
|
SNE(x, kk);
|
|
break;
|
|
|
|
case 0x5000:
|
|
SE_XY(x, y);
|
|
break;
|
|
|
|
|
|
case 0x6000: // 6XKK: Sets VX to KK
|
|
LD(x, kk);
|
|
break;
|
|
|
|
|
|
case 0x7000: // 7XKK: Adds KK to the value of VX
|
|
ADD(x, kk);
|
|
break;
|
|
|
|
|
|
case 0x8000: // Multi case opcode
|
|
switch (opcode & 0x000F)
|
|
{
|
|
case 0x0: // 8XY0: Set VX = VY
|
|
LD_XY(x, y);
|
|
break;
|
|
|
|
case 0x1: // 8XY1: Set VX = VX | VY
|
|
OR(x, y);
|
|
break;
|
|
|
|
|
|
case 0x2: // 8XY2: VX = VX & VY
|
|
AND(x, y);
|
|
break;
|
|
|
|
|
|
case 0x3: // 8XY3: VX = VX ^ VY
|
|
XOR(x, y);
|
|
break;
|
|
|
|
|
|
case 0x4: // 8XY4: VX = VX + VY; Carry = overflow
|
|
ADD_XY(x, y);
|
|
break;
|
|
|
|
|
|
case 0x5: // 8XY5: VX = VX - VY, set VF = NOT borrow
|
|
SUB(x, y);
|
|
break;
|
|
|
|
|
|
case 0x6: // 8XY6: VX = VX >> 1. VF = VX least significant bit
|
|
SHR(x, y);
|
|
break;
|
|
|
|
|
|
case 0x7: // 8XY7: VX = VY - VX, set VF = NOT borrow
|
|
SUBN(x, y);
|
|
break;
|
|
|
|
|
|
case 0xE:
|
|
SHL(x, y);
|
|
break;
|
|
|
|
|
|
default:
|
|
std::cerr << "Unknown OpCode" << std::endl;
|
|
interrupt = true;
|
|
//interrupt = true;
|
|
break;
|
|
} break;
|
|
|
|
|
|
case 0x9000: // 9XY0: Skip next instruction of VX != VY
|
|
SNE_XY(x, y);
|
|
break;
|
|
|
|
|
|
case 0xA000: // ANNN: Set register I to NNN
|
|
LD(nnn);
|
|
break;
|
|
|
|
|
|
case 0xB000: // BNNN: Jump to location NNN + V0
|
|
JP_V(nnn);
|
|
break;
|
|
|
|
|
|
case 0xC000: // Set VX to a random byte & kk
|
|
RND(x, kk);
|
|
break;
|
|
|
|
|
|
case 0xD000: // DXYN: Draw the N byte long sprite stored at I at position (VX, VY). Set VF = 1 if collision
|
|
DRW(x, y, n);
|
|
break;
|
|
|
|
|
|
case 0xE000: // Multi case opcode
|
|
switch (opcode & 0x00FF)
|
|
{
|
|
case 0x9E: // EX9E: Skip next instruction is key with value VX is pressed
|
|
SKP(x);
|
|
break;
|
|
|
|
|
|
case 0xA1: // EXA1: Skip next instruction is key with value VX is not pressed
|
|
SKNP(x);
|
|
break;
|
|
|
|
|
|
default:
|
|
std::cerr << "Unknown OpCode" << std::endl;
|
|
interrupt = true;
|
|
//interrupt = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case 0xF000: // Multi case opcode
|
|
switch (opcode & 0x00FF)
|
|
{
|
|
case 0x07: // FX07: Set VX = delay_timer
|
|
LD_X(x);
|
|
break;
|
|
|
|
|
|
case 0x0A: // FX0A: Halt program until key is pressed. Save key to VX
|
|
LD_K(x);
|
|
break;
|
|
|
|
|
|
case 0x15: // FX15: Set delay_timer = VX
|
|
LD_DT(x);
|
|
break;
|
|
|
|
|
|
case 0x18: // FX18: Set sound:timer = VX
|
|
LD_ST(x);
|
|
break;
|
|
|
|
|
|
case 0x1E: // FX1E: Set I = I + VX
|
|
ADD_I(x);
|
|
break;
|
|
|
|
|
|
case 0x29: // FX_29: Set I to font according to VX
|
|
LD_F(x);
|
|
break;
|
|
|
|
|
|
case 0x33: // FX33: Store BCD representation of VX in memory locations I, I+1 and I+2
|
|
LD_B(x);
|
|
break;
|
|
|
|
|
|
case 0x55: // Fill memory starting at I with values from V0 to VX
|
|
LD_55(x);
|
|
break;
|
|
|
|
|
|
case 0x65: // FX65: Fill V0 - VX with memory values starting at I
|
|
LD_65(x);
|
|
break;
|
|
|
|
default:
|
|
std::cerr << "Unknown OpCode" << std::endl;
|
|
interrupt = true;
|
|
//interrupt = true;
|
|
break;
|
|
|
|
} break;
|
|
|
|
|
|
|
|
default:
|
|
std::cerr << "Unknown OpCode" << std::endl;
|
|
interrupt = true;
|
|
//interrupt = true;
|
|
break;
|
|
}
|
|
|
|
// Update timers
|
|
}
|
|
|
|
private:
|
|
WORD opcode;
|
|
|
|
BYTE memory[RAM];
|
|
BYTE V[16];
|
|
|
|
WORD I;
|
|
WORD pc;
|
|
|
|
BYTE gfx[WIDTH * HEIGHT];
|
|
|
|
WORD stack[16];
|
|
WORD sp;
|
|
|
|
BYTE key[16];
|
|
|
|
private: // Opcodes
|
|
|
|
///////////////////0x00E0///////////////////
|
|
/// \brief Clears display
|
|
///
|
|
////////////////////////////////////////////
|
|
void CLS()
|
|
{
|
|
std::fill(std::begin(gfx), std::end(gfx), 0);
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Screen cleared" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0x00EE///////////////////
|
|
/// \brief Returns from subroutine
|
|
///
|
|
////////////////////////////////////////////
|
|
void RET()
|
|
{
|
|
pc = stack[--sp] + 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Returned from subroutine" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
///////////////////0x1NNN///////////////////
|
|
/// \brief Jumps to NNN
|
|
///
|
|
/// \param address NNN
|
|
///
|
|
////////////////////////////////////////////
|
|
void JP(WORD address)
|
|
{
|
|
pc = address;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Jumped to 0x" << address << std::endl;
|
|
#endif
|
|
}
|
|
|
|
///////////////////0x2NNN///////////////////
|
|
/// \brief Calls subroutine at NNN
|
|
///
|
|
/// \param address NNN
|
|
////////////////////////////////////////////
|
|
void CALL(WORD address)
|
|
{
|
|
stack[sp++] = pc;
|
|
pc = address;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Called subroutine at 0x" << address << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0x3XKK///////////////////
|
|
/// \brief Skip next instr if VX = KK
|
|
///
|
|
/// \param regX X
|
|
/// \param byte KK
|
|
///
|
|
////////////////////////////////////////////
|
|
void SE(BYTE regX, BYTE kk)
|
|
{
|
|
if (V[regX] == kk)
|
|
{
|
|
pc += 0x04;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Skipped instruction because V" << (WORD)regX << " == " << (WORD)kk << std::endl;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Didn't skip instruction because V" << (WORD)regX << " != " << (WORD)kk << std::endl;
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|
|
|
|
///////////////////0x4XKK///////////////////
|
|
/// \brief Skip next instr if VX != KK
|
|
///
|
|
/// \param regX X
|
|
/// \param byte KK
|
|
///
|
|
////////////////////////////////////////////
|
|
void SNE(BYTE regX, BYTE kk)
|
|
{
|
|
if (V[regX] != kk)
|
|
{
|
|
pc += 0x04;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Skipped instruction because V" << (WORD)regX << " != " << (WORD)kk << std::endl;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Didn't skip instruction because V" << (WORD)regX << " == " << (WORD)kk << std::endl;
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|
|
|
|
///////////////////0x5XY0///////////////////
|
|
/// \brief Skip next instr if VX == VY
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
///
|
|
////////////////////////////////////////////
|
|
void SE_XY(BYTE regX, BYTE regY)
|
|
{
|
|
if (V[regX] == V[regY])
|
|
{
|
|
pc += 0x04;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Skipped instruction because V" << (WORD)regX << " != V" << (WORD)regY << std::endl;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Didn't skip instruction because V" << (WORD)regX << " == V" << (WORD)regY << std::endl;
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|
|
|
|
///////////////////0x6XKK///////////////////
|
|
/// \brief Sets VX to KK
|
|
///
|
|
/// \param regX X
|
|
/// \param byte KK
|
|
////////////////////////////////////////////
|
|
void LD(BYTE regX, BYTE byte)
|
|
{
|
|
V[regX] = byte;
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Set V" << (WORD)regX << " to 0x" << (WORD)byte << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x7XKK///////////////////
|
|
/// \brief Adds KK to VX
|
|
///
|
|
/// \param regX X
|
|
/// \param byte KK
|
|
////////////////////////////////////////////
|
|
void ADD(BYTE regX, BYTE byte)
|
|
{
|
|
V[regX] += byte;
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Added 0x" << (WORD)byte << " to V" << (WORD)regX << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY0///////////////////
|
|
/// \brief Stores value of VY in VX
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void LD_XY(BYTE regX, BYTE regY)
|
|
{
|
|
V[regX] = V[regY];
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "V" << (WORD)regY << "(0x" << (WORD) V[regY] << ") => V" << (WORD)regX << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY1///////////////////
|
|
/// \brief VX = VX | VY
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void OR(BYTE regX, BYTE regY)
|
|
{
|
|
V[regX] |= V[regY];
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "V" << (WORD)regX << " |= V" << (WORD)regY << "(0x" << (WORD)V[regY] << ") => " << (WORD)V[regX] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY2///////////////////
|
|
/// \brief VX = VX & VY
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void AND(BYTE regX, BYTE regY)
|
|
{
|
|
V[regX] &= V[regY];
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "V" << (WORD)regX << " &= V" << (WORD)regY << "(0x" << (WORD)V[regY] << ") => " << (WORD)V[regX] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY3///////////////////
|
|
/// \brief VX = VX ^ VY
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void XOR(BYTE regX, BYTE regY)
|
|
{
|
|
V[regX] ^= V[regY];
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "V" << (WORD)regX << " ^= V" << (WORD)regY << "(0x" << (WORD)V[regY] << ") => " << (WORD)V[regX] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY4///////////////////
|
|
/// \brief VX = VX + VY, VF = carry
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void ADD_XY(BYTE regX, BYTE regY)
|
|
{
|
|
if (V[regY] > 0xFF - V[regX])
|
|
V[0xF] = 1;
|
|
else
|
|
V[0xF] = 0;
|
|
|
|
V[regX] = (V[regX] + V[regY]) & 0xFF;
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "V" << (WORD)regX << " += V" << (WORD)regY << "(0x" << (WORD)V[regY] << ") => " << (WORD)V[regX] << ", Carry = " << (WORD)V[0xF] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY5///////////////////
|
|
/// \brief VX = VX - VY, VF = NOT borrow
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void SUB(BYTE regX, BYTE regY)
|
|
{
|
|
if (V[regX] > V[regY])
|
|
V[0xF] = 1;
|
|
else
|
|
V[0xF] = 0;
|
|
|
|
V[regX] = (V[regX] - V[regY]) & 0xFF;
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "V" << (WORD)regX << " -= V" << (WORD)regY << "(0x" << (WORD)V[regY] << ") => " << (WORD)V[regX] << ", Carry = " << (WORD)V[0xF] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY6///////////////////
|
|
/// \brief VX = VX >> 1, VF = LSB of VX
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void SHR(BYTE regX, BYTE regY)
|
|
{
|
|
V[0xF] = V[regX] & 0x1;
|
|
V[regX] >>= 1;
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Shifted V" << (WORD)regX << " right once. VF = " << (WORD)V[0xF] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XY7///////////////////
|
|
/// \brief VX = VY - VX, VF = NOT borrow
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void SUBN(BYTE regX, BYTE regY)
|
|
{
|
|
if (V[regY] > V[regX])
|
|
V[0xF] = 1;
|
|
else
|
|
V[0xF] = 0;
|
|
|
|
V[regX] = (V[regY] - V[regX]) & 0xFF;
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "V" << (WORD)regX << " = V" << (WORD)regY << "(0x" << (WORD)V[regY] << ") - V" << (WORD)regX << " => " << (WORD)V[regX] << ", Carry = " << (WORD)V[0xF] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//////////////////0x8XYE///////////////////
|
|
/// \brief VX = VX >> 1, VF = LSB of VX
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
////////////////////////////////////////////
|
|
void SHL(BYTE regX, BYTE regY)
|
|
{
|
|
V[0xF] = V[regX] & 0x80;
|
|
V[regX] <<= 1;
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Shifted V" << (WORD)regX << " left once. VF = " << (WORD)V[0xF] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0x9XY0///////////////////
|
|
/// \brief Skip next instr if VX != VY
|
|
///
|
|
/// \param regX X
|
|
/// \param regY Y
|
|
///
|
|
////////////////////////////////////////////
|
|
void SNE_XY(BYTE regX, BYTE regY)
|
|
{
|
|
if (V[regX] != V[regY])
|
|
{
|
|
pc += 0x04;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Skipped instruction because V" << (WORD)regX << " != V" << (WORD)regY << std::endl;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Didn't skip instruction because V" << (WORD)regX << " == V" << (WORD)regY << std::endl;
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|
|
|
|
///////////////////0xANNN///////////////////
|
|
/// \brief Sets I to NNN
|
|
///
|
|
/// \param address NNN
|
|
////////////////////////////////////////////
|
|
void LD(WORD address)
|
|
{
|
|
I = address;
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Set I to 0x" << address << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xBNNN///////////////////
|
|
/// \brief Jump to location NNN + V0
|
|
///
|
|
/// \param address NNN
|
|
////////////////////////////////////////////
|
|
void JP_V(WORD address)
|
|
{
|
|
pc = address + V[0x0];
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Jumped to adress " << (WORD)pc << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xCXKK///////////////////
|
|
/// \brief Sets VX to a random byte ANDed with KK
|
|
///
|
|
/// \param regX X
|
|
/// \param byte KK
|
|
////////////////////////////////////////////
|
|
void RND(BYTE regX, BYTE byte)
|
|
{
|
|
static std::default_random_engine engine(std::chrono::system_clock::now().time_since_epoch().count());
|
|
static std::uniform_int_distribution<WORD> range(0, 0xFF);
|
|
|
|
BYTE rnd = range(engine) & byte;
|
|
|
|
V[regX] = rnd;
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "(Random) Set V" << (WORD)regX << " to 0x" << (WORD)rnd << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xDXYN///////////////////
|
|
/// \brief Draws sprite that is N bytes long and
|
|
/// stored at I at position (VX, VY). Set
|
|
/// VF = 1 if collision
|
|
///
|
|
/// \param regX x
|
|
/// \param regY y
|
|
/// \param bytes N
|
|
////////////////////////////////////////////
|
|
void DRW(BYTE regX, BYTE regY, BYTE bytes)
|
|
{
|
|
V[0xF] = 0x00;
|
|
|
|
for (BYTE y = 0; y < bytes; y++)
|
|
{
|
|
BYTE line = memory[I + y];
|
|
|
|
for (BYTE x = 0; x < 8; x++)
|
|
{
|
|
BYTE pixel = line & (0x80 >> x);
|
|
if (pixel != 0)
|
|
{
|
|
BYTE totalX = V[regX] + x;
|
|
BYTE totalY = V[regY] + y;
|
|
WORD index = totalY * 64 + totalX;
|
|
|
|
if (gfx[index] == 1) {
|
|
V[0xF] = 1;
|
|
}
|
|
|
|
gfx[index] ^= 1;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
pc += 0x02;
|
|
drawFlag = true;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Drew Sprite at position (V" << (WORD)regX << ", V" << (WORD)regY << ")[" << std::dec << (WORD)V[regX] << ", " << (WORD)V[regY] << "]" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xEX9E///////////////////
|
|
/// \brief Skip instruction if key of value VX is pressed
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void SKP(BYTE regX)
|
|
{
|
|
if (GetKeyState(keymap.find(V[regX])->second) & 0x8000)
|
|
{
|
|
pc += 0x04;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Skipped instruction because key " << (WORD)V[regX] << " was pressed" << std::endl;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Didn't skip instruction because key " << (WORD)V[regX] << " was not pressed" << std::endl;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////0xEXA1///////////////////
|
|
/// \brief Skip instruction if key of value VX is not pressed
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void SKNP(BYTE regX)
|
|
{
|
|
if (GetKeyState(keymap.find(V[regX])->second) & 0x8000)
|
|
{
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Didn't skip instruction because key " << (WORD)V[regX] << " was pressed" << std::endl;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pc += 0x04;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Skipped instruction because key " << (WORD)V[regX] << " was not pressed" << std::endl;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////0xFX07///////////////////
|
|
/// \brief Store BCD representation of X at I
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_X(BYTE regX)
|
|
{
|
|
V[regX] = delay_timer;
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Set V" << (WORD)regX << " to delay_timer(" << (WORD)delay_timer << ")" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xFX0A///////////////////
|
|
/// \brief Halt program until key press. Save key to VX
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_K(BYTE regX)
|
|
{
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Waiting for Key press..." << std::endl;
|
|
#endif
|
|
for (BYTE key = 0x0; key < 0xF; key++)
|
|
{
|
|
if (GetKeyState(keymap.find(key)->second) & 0x8000)
|
|
{
|
|
V[regX] = key;
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Key pressed: 0x" << (WORD)key << ". Saved to V" << (WORD)regX << std::endl;
|
|
#endif
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////0xFX15///////////////////
|
|
/// \brief Set delay timer to VX
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_DT(BYTE regX)
|
|
{
|
|
delay_timer = V[regX];
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Set delay timer to " << (WORD)V[regX] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xFX18///////////////////
|
|
/// \brief Set sound timer to VX
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_ST(BYTE regX)
|
|
{
|
|
sound_timer = V[regX];
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Set sound timer to " << (WORD)V[regX] << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xFX1E///////////////////
|
|
/// \brief Set I = I + VX
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void ADD_I(BYTE regX)
|
|
{
|
|
I += V[regX];
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Added V" << (WORD)regX << "(" << (WORD)V[regX] << ") to I. I = " << (WORD)I << std::endl;
|
|
#endif
|
|
}
|
|
|
|
///////////////////0xFX29///////////////////
|
|
/// \brief Set I to location of font for digit VX
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_F(BYTE regX)
|
|
{
|
|
I = 0x0000 + (V[regX] * 5);
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Stored font \"" << (WORD)V[regX] << "\" at I" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xFX33///////////////////
|
|
/// \brief Store BCD representation of X at I
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_B(BYTE regX)
|
|
{
|
|
BYTE value = V[regX];
|
|
|
|
BYTE hundreds = (value - (value % 100)) / 100;
|
|
value -= hundreds * 100;
|
|
|
|
BYTE tens = (value - (value % 10)) / 10;
|
|
value -= tens * 10;
|
|
|
|
memory[I] = hundreds;
|
|
memory[I + 1] = tens;
|
|
memory[I + 2] = value;
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Storing Binary Coded Decimal V" << (WORD)regX << " as {" << std::dec << (WORD)hundreds << ", " << (WORD)tens << ", " << (WORD)value << "}" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xFX55///////////////////
|
|
/// \brief Fill memory at I with values from V0 - VX
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_55(BYTE regX)
|
|
{
|
|
for (int offset = 0; offset <= regX; offset++)
|
|
{
|
|
memory[I + offset] = V[offset];
|
|
}
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Filled memory starting at 0x" << (WORD)I << " with the values of V0 to V" << (WORD)regX << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////0xFX65///////////////////
|
|
/// \brief Fill V0 - VX with memory data starting at I
|
|
///
|
|
/// \param regX X
|
|
///
|
|
////////////////////////////////////////////
|
|
void LD_65(BYTE regX)
|
|
{
|
|
for (int offset = 0; offset <= regX; offset++)
|
|
{
|
|
V[offset] = memory[I + offset];
|
|
}
|
|
|
|
pc += 0x02;
|
|
|
|
#ifndef SUPPRESS_PROC_INFO
|
|
std::cout << "Filled V0 through V" << (WORD)regX << " with memory values starting at 0x" << I << std::endl;
|
|
#endif
|
|
}
|
|
} chip8;
|
|
|
|
|
|
|
|
|
|
class olcConsoleGameEngine
|
|
{
|
|
public:
|
|
olcConsoleGameEngine()
|
|
{
|
|
m_nScreenWidth = 80;
|
|
m_nScreenHeight = 30;
|
|
|
|
m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
m_hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);
|
|
|
|
m_sAppName = L"Default";
|
|
}
|
|
|
|
int ConstructConsole(int width, int height, int fontw, int fonth)
|
|
{
|
|
if (m_hConsole == INVALID_HANDLE_VALUE)
|
|
return Error(L"Bad Handle");
|
|
|
|
m_nScreenWidth = width;
|
|
m_nScreenHeight = height;
|
|
|
|
m_rectWindow = { 0, 0, 1, 1 };
|
|
SetConsoleWindowInfo(m_hConsole, TRUE, &m_rectWindow);
|
|
|
|
// Set the size of the screen buffer
|
|
COORD coord = { (short)m_nScreenWidth, (short)m_nScreenHeight };
|
|
if (!SetConsoleScreenBufferSize(m_hConsole, coord))
|
|
Error(L"SetConsoleScreenBufferSize");
|
|
|
|
// Assign screen buffer to the console
|
|
if (!SetConsoleActiveScreenBuffer(m_hConsole))
|
|
return Error(L"SetConsoleActiveScreenBuffer");
|
|
|
|
// Set the font size now that the screen buffer has been assigned to the console
|
|
CONSOLE_FONT_INFOEX cfi;
|
|
cfi.cbSize = sizeof(cfi);
|
|
cfi.nFont = 0;
|
|
cfi.dwFontSize.X = fontw;
|
|
cfi.dwFontSize.Y = fonth;
|
|
cfi.FontFamily = FF_DONTCARE;
|
|
cfi.FontWeight = FW_NORMAL;
|
|
|
|
/* DWORD version = GetVersion();
|
|
DWORD major = (DWORD)(LOBYTE(LOWORD(version)));
|
|
DWORD minor = (DWORD)(HIBYTE(LOWORD(version)));*/
|
|
|
|
//if ((major > 6) || ((major == 6) && (minor >= 2) && (minor < 4)))
|
|
// wcscpy_s(cfi.FaceName, L"Raster"); // Windows 8 :(
|
|
//else
|
|
// wcscpy_s(cfi.FaceName, L"Lucida Console"); // Everything else :P
|
|
|
|
//wcscpy_s(cfi.FaceName, L"Liberation Mono");
|
|
wcscpy_s(cfi.FaceName, L"Consolas");
|
|
if (!SetCurrentConsoleFontEx(m_hConsole, false, &cfi))
|
|
return Error(L"SetCurrentConsoleFontEx");
|
|
|
|
// Get screen buffer info and check the maximum allowed window size. Return
|
|
// error if exceeded, so user knows their dimensions/fontsize are too large
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
if (!GetConsoleScreenBufferInfo(m_hConsole, &csbi))
|
|
return Error(L"GetConsoleScreenBufferInfo");
|
|
if (m_nScreenHeight > csbi.dwMaximumWindowSize.Y)
|
|
return Error(L"Screen Height / Font Height Too Big");
|
|
if (m_nScreenWidth > csbi.dwMaximumWindowSize.X)
|
|
return Error(L"Screen Width / Font Width Too Big");
|
|
|
|
// Set Physical Console Window Size
|
|
m_rectWindow = { 0, 0, (short)m_nScreenWidth - 1, (short)m_nScreenHeight - 1 };
|
|
if (!SetConsoleWindowInfo(m_hConsole, TRUE, &m_rectWindow))
|
|
return Error(L"SetConsoleWindowInfo");
|
|
|
|
// Set flags to allow mouse input
|
|
if (!SetConsoleMode(m_hConsoleIn, ENABLE_EXTENDED_FLAGS | ENABLE_WINDOW_INPUT | ENABLE_MOUSE_INPUT))
|
|
return Error(L"SetConsoleMode");
|
|
|
|
// Allocate memory for screen buffer
|
|
m_bufScreen = new CHAR_INFO[m_nScreenWidth*m_nScreenHeight];
|
|
memset(m_bufScreen, 0, sizeof(CHAR_INFO) * m_nScreenWidth * m_nScreenHeight);
|
|
|
|
SetConsoleCtrlHandler((PHANDLER_ROUTINE)CloseHandler, TRUE);
|
|
return 1;
|
|
}
|
|
|
|
virtual void Draw(int x, int y, short c = 0x2588, short col = 0x000F)
|
|
{
|
|
if (x >= 0 && x < m_nScreenWidth && y >= 0 && y < m_nScreenHeight)
|
|
{
|
|
m_bufScreen[y * m_nScreenWidth + x].Char.UnicodeChar = c;
|
|
m_bufScreen[y * m_nScreenWidth + x].Attributes = col;
|
|
}
|
|
}
|
|
|
|
void Clip(int &x, int &y)
|
|
{
|
|
if (x < 0) x = 0;
|
|
if (x >= m_nScreenWidth) x = m_nScreenWidth;
|
|
if (y < 0) y = 0;
|
|
if (y >= m_nScreenHeight) y = m_nScreenHeight;
|
|
}
|
|
|
|
~olcConsoleGameEngine()
|
|
{
|
|
SetConsoleActiveScreenBuffer(m_hOriginalConsole);
|
|
delete[] m_bufScreen;
|
|
}
|
|
|
|
public:
|
|
void Start()
|
|
{
|
|
// Start the thread
|
|
m_bAtomActive = true;
|
|
std::thread t = std::thread(&olcConsoleGameEngine::GameThread, this);
|
|
|
|
// Wait for thread to be exited
|
|
t.join();
|
|
}
|
|
|
|
int ScreenWidth()
|
|
{
|
|
return m_nScreenWidth;
|
|
}
|
|
|
|
int ScreenHeight()
|
|
{
|
|
return m_nScreenHeight;
|
|
}
|
|
|
|
private:
|
|
void GameThread()
|
|
{
|
|
// Create user resources as part of this thread
|
|
if (!OnUserCreate())
|
|
m_bAtomActive = false;
|
|
|
|
auto tp1 = std::chrono::system_clock::now();
|
|
auto tp2 = std::chrono::system_clock::now();
|
|
|
|
while (m_bAtomActive)
|
|
{
|
|
// Run as fast as possible
|
|
while (m_bAtomActive)
|
|
{
|
|
// Handle Timing
|
|
tp2 = std::chrono::system_clock::now();
|
|
std::chrono::duration<float> elapsedTime = tp2 - tp1;
|
|
tp1 = tp2;
|
|
float fElapsedTime = elapsedTime.count();
|
|
|
|
|
|
// Handle Frame Update
|
|
if (!OnUserUpdate(fElapsedTime))
|
|
m_bAtomActive = false;
|
|
|
|
// Update Title & Present Screen Buffer
|
|
wchar_t s[256];
|
|
swprintf_s(s, 256, L"OneLoneCoder.com - Console Game Engine - %s - FPS: %3.2f", m_sAppName.c_str(), 1.0f / fElapsedTime);
|
|
SetConsoleTitle(s);
|
|
WriteConsoleOutput(m_hConsole, m_bufScreen, { (short)m_nScreenWidth, (short)m_nScreenHeight }, { 0,0 }, &m_rectWindow);
|
|
}
|
|
|
|
if (m_bEnableSound)
|
|
{
|
|
// Close and Clean up audio system
|
|
}
|
|
|
|
// Allow the user to free resources if they have overrided the destroy function
|
|
if (OnUserDestroy())
|
|
{
|
|
// User has permitted destroy, so exit and clean up
|
|
delete[] m_bufScreen;
|
|
SetConsoleActiveScreenBuffer(m_hOriginalConsole);
|
|
m_cvGameFinished.notify_one();
|
|
}
|
|
else
|
|
{
|
|
// User denied destroy for some reason, so continue running
|
|
m_bAtomActive = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public:
|
|
// User MUST OVERRIDE THESE!!
|
|
virtual bool OnUserCreate() = 0;
|
|
virtual bool OnUserUpdate(float fElapsedTime) = 0;
|
|
|
|
// Optional for clean up
|
|
virtual bool OnUserDestroy() { return true; }
|
|
|
|
protected:
|
|
int Error(const wchar_t *msg)
|
|
{
|
|
wchar_t buf[256];
|
|
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 256, NULL);
|
|
SetConsoleActiveScreenBuffer(m_hOriginalConsole);
|
|
wprintf(L"ERROR: %s\n\t%s\n", msg, buf);
|
|
return 0;
|
|
}
|
|
|
|
static BOOL CloseHandler(DWORD evt)
|
|
{
|
|
// Note this gets called in a seperate OS thread, so it must
|
|
// only exit when the game has finished cleaning up, or else
|
|
// the process will be killed before OnUserDestroy() has finished
|
|
if (evt == CTRL_CLOSE_EVENT)
|
|
{
|
|
m_bAtomActive = false;
|
|
|
|
// Wait for thread to be exited
|
|
std::unique_lock<std::mutex> ul(m_muxGame);
|
|
m_cvGameFinished.wait(ul);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected:
|
|
int m_nScreenWidth;
|
|
int m_nScreenHeight;
|
|
CHAR_INFO *m_bufScreen;
|
|
std::wstring m_sAppName;
|
|
HANDLE m_hOriginalConsole;
|
|
CONSOLE_SCREEN_BUFFER_INFO m_OriginalConsoleInfo;
|
|
HANDLE m_hConsole;
|
|
HANDLE m_hConsoleIn;
|
|
SMALL_RECT m_rectWindow;
|
|
short m_keyOldState[256] = { 0 };
|
|
short m_keyNewState[256] = { 0 };
|
|
bool m_mouseOldState[5] = { 0 };
|
|
bool m_mouseNewState[5] = { 0 };
|
|
bool m_bConsoleInFocus = true;
|
|
bool m_bEnableSound = false;
|
|
|
|
// These need to be static because of the OnDestroy call the OS may make. The OS
|
|
// spawns a special thread just for that
|
|
static std::atomic<bool> m_bAtomActive;
|
|
static std::condition_variable m_cvGameFinished;
|
|
static std::mutex m_muxGame;
|
|
};
|
|
|
|
// Define our static variables
|
|
std::atomic<bool> olcConsoleGameEngine::m_bAtomActive(false);
|
|
std::condition_variable olcConsoleGameEngine::m_cvGameFinished;
|
|
std::mutex olcConsoleGameEngine::m_muxGame;
|
|
|
|
|
|
//////////////////////////////////////////////
|
|
/// \brief Initializes and handles Screen
|
|
///
|
|
//////////////////////////////////////////////
|
|
class Screen : public olcConsoleGameEngine
|
|
{
|
|
public:
|
|
Screen(){}
|
|
|
|
virtual bool OnUserCreate()
|
|
{
|
|
then = std::chrono::system_clock::now();
|
|
|
|
chip8.Initialize();
|
|
chip8.LoadGame(FILENAME);
|
|
//MessageBox(NULL, L"", L"", MB_OK);
|
|
|
|
return true;
|
|
}
|
|
|
|
virtual bool OnUserUpdate(float elapsedTime)
|
|
{
|
|
chip8.EmulateCycle();
|
|
|
|
now = std::chrono::system_clock::now();
|
|
|
|
if (std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::milliseconds>(then.time_since_epoch()).count() >= 1000 / 60)
|
|
{
|
|
//std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::milliseconds>(then.time_since_epoch()).count() << std::endl;
|
|
|
|
if (chip8.delay_timer != 0)
|
|
{
|
|
chip8.delay_timer--;
|
|
}
|
|
if (chip8.sound_timer != 0) {
|
|
chip8.sound_timer--;
|
|
}
|
|
|
|
then = now;
|
|
|
|
}
|
|
|
|
if (chip8.drawFlag)
|
|
{
|
|
drawGraphics();
|
|
}
|
|
Sleep(1);
|
|
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
std::chrono::system_clock::time_point then, now;
|
|
|
|
//////////////////////////////////////////////
|
|
/// \brief Draws the pixel array to the screen
|
|
///
|
|
/// \param window The render target
|
|
/// \param pixels The pixel array
|
|
///
|
|
//////////////////////////////////////////////
|
|
void drawGraphics()
|
|
{
|
|
BYTE* gfx = chip8.getDisplay();
|
|
|
|
for (int i = 0; i < WIDTH * HEIGHT; i++)
|
|
{
|
|
int y = floor(i / WIDTH);
|
|
int x = i - (y * WIDTH);
|
|
COLOUR col = (gfx[i] == 0x00) ? FG_BLACK : FG_WHITE;
|
|
|
|
std::wstring s = std::to_wstring(x) + L", " + std::to_wstring(y);
|
|
|
|
Draw(x, y, PIXEL_SOLID, col);
|
|
}
|
|
|
|
chip8.drawFlag = false;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
Screen screen;
|
|
screen.ConstructConsole(WIDTH, HEIGHT, 16, 16);
|
|
screen.Start();
|
|
|
|
|
|
|
|
return 0;
|
|
}
|