Chip8.cpp

#include <cstdint>
#include <cstring>
#include <fstream>
#include <iostream>
#include <random>

class Chip8 {
public:
    uint8_t registers[16]{};
    uint8_t memory[4096]{};
    uint16_t index{};
    uint16_t pc{};
    uint16_t stack[16]{};
    uint8_t sp{};
    uint8_t delayTimer{};
    uint8_t soundTimer{};
    uint8_t keypad[16]{};
    uint32_t video[64 * 32]{};
    uint16_t opcode;

    const unsigned int ROM_START_ADRESS = 0x200;
    const unsigned int FONT_START_ADRESS = 0x050;

#define FONTSET_SIZE 80
#define VIDEO_WIDTH 64
#define VIDEO_HEIGHT 32

    const unsigned char 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
    };

    Chip8() {
        pc = ROM_START_ADRESS;
        loadFont();
    }

    int random8BitNumber() { return rand() % 256; }

    void loadRom(char const* filename) {
        std::ifstream file(filename, std::ios::binary | std::ios::ate);
        if (file.is_open()) {
            std::streampos size = file.tellg();
            if (size > 0) {
                char* buffer = new char[size];
                file.seekg(0, std::ios::beg);
                file.read(buffer, size);
                file.close();

                for (long i = 0; i < size; i++) {
                    memory[ROM_START_ADRESS + i] = static_cast<uint8_t>(buffer[i]);
                }
                delete[] buffer;
            }
        }
    }

    void loadFont() {
        for (unsigned int i = 0; i < FONTSET_SIZE; i++) {
            memory[FONT_START_ADRESS + i] = fontset[i];
        }
    }


    void OP_00E0() { memset(video, 0, sizeof(video)); }

    void OP_00EE() {
        sp--;
        pc = stack[sp];
    }

    void OP_1NNN() {
        pc = opcode & 0x0FFFu;
    }

    void OP_2NNN() {
        stack[sp] = pc;
        sp++;
        pc = opcode & 0x0FFFu;
    }

    void OP_3XKK() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t byte = opcode & 0x00FFu;
        if (registers[Vx] == byte) { pc += 2; }
    }

    void OP_4XKK() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t byte = opcode & 0x00FFu;
        if (registers[Vx] != byte) { pc += 2; }
    }

    void OP_5XY0() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        if (registers[Vx] == registers[Vy]) {
            pc += 2;
        }
    }

    void OP_6XKK() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        registers[Vx] = opcode & 0x00FFu;
    }

    void OP_7XKK() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        registers[Vx] += (opcode & 0x00FFu);
    }

    void OP_8XY0() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        registers[Vx] = registers[Vy];
    }

    void OP_8XY1() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        registers[Vx] |= registers[Vy];
    }

    void OP_8XY2() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        registers[Vx] &= registers[Vy];
    }

    void OP_8XY3() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        registers[Vx] ^= registers[Vy];
    }

    void OP_8XY4() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        uint16_t sum = registers[Vx] + registers[Vy];
        registers[0xF] = (sum > 255u) ? 1 : 0;
        registers[Vx] = sum & 0xFFu;
    }

    void OP_8XY5() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        uint8_t valX = registers[Vx];
        uint8_t valY = registers[Vy];
        registers[0xF] = (valX >= valY) ? 1 : 0;
        registers[Vx] = valX - valY;
    }

    void OP_8XY6() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        registers[0xF] = (registers[Vx] & 0x01u);
        registers[Vx] >>= 1; 
    }

    void OP_8XY7() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        registers[0xF] = (registers[Vy] >= registers[Vx]) ? 1 : 0;
        registers[Vx] = registers[Vy] - registers[Vx];
    }

    void OP_8XYE() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        registers[0xF] = (registers[Vx] & 0x80u) >> 7u;
        registers[Vx] <<= 1; 
    }

    void OP_9XY0() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        if (registers[Vx] != registers[Vy]) { pc += 2; }
    }

    void OP_ANNN() { index = opcode & 0x0FFF; }

    void OP_BNNN() {
        pc = registers[0] + (opcode & 0x0FFF);
    }

    void OP_CXKK() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        registers[Vx] = random8BitNumber() & (opcode & 0x00FFu);
    }

    void OP_DXYN() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        uint8_t Vy = (opcode & 0x00F0u) >> 4u;
        uint8_t height = (opcode & 0x000Fu);
        uint8_t xPos = registers[Vx] % 64;
        uint8_t yPos = registers[Vy] % 32;

        registers[0xF] = 0;

        for (unsigned int row = 0; row < height; row++) {
            uint8_t spriteByte = memory[index + row];
            for (unsigned int col = 0; col < 8; col++) {
                uint8_t spritePixel = spriteByte & (0x80u >> col);
                if ((yPos + row) < 32 && (xPos + col) < 64) {
                    uint32_t* screenPixel = &video[(yPos + row) * 64 + (xPos + col)];
                    if (spritePixel) {
                        if (*screenPixel == 0xFFFFFFFF) { registers[0xF] = 1; }
                        *screenPixel ^= 0xFFFFFFFF;
                    }
                }
            }
        }
    }

    void OP_EX9E() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        if (keypad[registers[Vx]]) { pc += 2; }
    }

    void OP_EXA1() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        if (!keypad[registers[Vx]]) { pc += 2; }
    }

    void OP_FX07() {
        registers[(opcode & 0x0F00u) >> 8u] = delayTimer;
    }

    void OP_FX0A() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        bool pressed = false;
        for (int i = 0; i < 16; i++) {
            if (keypad[i]) {
                registers[Vx] = i;
                pressed = true;
                break;
            }
        }
        if (!pressed) { pc -= 2; }
    }

    void OP_FX15() { delayTimer = registers[(opcode & 0x0F00u) >> 8u]; }
    void OP_FX18() { soundTimer = registers[(opcode & 0x0F00u) >> 8u]; }
    void OP_FX1E() { index += registers[(opcode & 0x0F00u) >> 8u]; }

    void OP_FX29() {
        index = FONT_START_ADRESS + (5 * registers[(opcode & 0x0F00u) >> 8u]);
    }

    void OP_FX33() {
        uint8_t value = registers[(opcode & 0x0F00u) >> 8u];
        memory[index + 2] = value % 10;
        value /= 10;
        memory[index + 1] = value % 10;
        value /= 10;
        memory[index] = value % 10;
    }

    void OP_FX55() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        for (uint8_t i = 0; i <= Vx; i++) { memory[index + i] = registers[i]; }
    }

    void OP_FX65() {
        uint8_t Vx = (opcode & 0x0F00u) >> 8u;
        for (uint8_t i = 0; i <= Vx; i++) { registers[i] = memory[index + i]; }
    }

    void Cycle() {
        opcode = (memory[pc] << 8u) | memory[pc + 1];
        pc += 2;

        switch (opcode & 0xF000u) {
            case 0x0000:
                switch (opcode & 0x00FFu) {
                    case 0xE0: OP_00E0(); break;
                    case 0xEE: OP_00EE(); break;
                } break;
            case 0x1000: OP_1NNN(); break;
            case 0x2000: OP_2NNN(); break;
            case 0x3000: OP_3XKK(); break;
            case 0x4000: OP_4XKK(); break;
            case 0x5000: OP_5XY0(); break;
            case 0x6000: OP_6XKK(); break;
            case 0x7000: OP_7XKK(); break;
            case 0x8000:
                switch (opcode & 0x000Fu) {
                    case 0x0: OP_8XY0(); break;
                    case 0x1: OP_8XY1(); break;
                    case 0x2: OP_8XY2(); break;
                    case 0x3: OP_8XY3(); break;
                    case 0x4: OP_8XY4(); break;
                    case 0x5: OP_8XY5(); break;
                    case 0x6: OP_8XY6(); break;
                    case 0x7: OP_8XY7(); break;
                    case 0xE: OP_8XYE(); break;
                } break;
            case 0x9000: OP_9XY0(); break;
            case 0xA000: OP_ANNN(); break;
            case 0xB000: OP_BNNN(); break;
            case 0xC000: OP_CXKK(); break;
            case 0xD000: OP_DXYN(); break;
            case 0xE000:
                switch (opcode & 0x00FFu) {
                    case 0x9E: OP_EX9E(); break;
                    case 0xA1: OP_EXA1(); break;
                } break;
            case 0xF000:
                switch (opcode & 0x00FFu) {
                    case 0x07: OP_FX07(); break;
                    case 0x0A: OP_FX0A(); break;
                    case 0x15: OP_FX15(); break;
                    case 0x18: OP_FX18(); break;
                    case 0x1E: OP_FX1E(); break;
                    case 0x29: OP_FX29(); break;
                    case 0x33: OP_FX33(); break;
                    case 0x55: OP_FX55(); break;
                    case 0x65: OP_FX65(); break;
                } break;
        }

        if (delayTimer > 0) delayTimer--;
        if (soundTimer > 0) soundTimer--;
    }
};