chip8.cpp

#include "chip8.h"

#include <cstring>
#include <cstdlib>
#include <cstdint>
#include <ctime>
#include <cstdio>

Chip8::Chip8()
{
}

Chip8::~Chip8()
{
}

void Chip8::initialize()
{
    srand(time(NULL));

    pc = 0x200;
    opcode = 0;
    I = 0;
    sp = 0;

    memset(gfx, 0, sizeof(gfx));
    memset(stack, 0, sizeof(stack));
    memset(V, 0, sizeof(V));
    memset(memory, 0, sizeof(memory));
    memset(key, 0, sizeof(key));

    for (int i = 0; i < 80; ++i)
        memory[i] = chip8_fontset[i];

    delay_timer = 0;
    sound_timer = 0;
    drawFlag    = false;
    soundFlag   = false;
}

// Bug fix: 파라미터 memory 제거 (멤버 this->memory를 가리던 shadowing 버그)
// Bug fix: ftell 리턴값을 long으로 받아 음수(-1) 에러 감지 가능하게 수정
bool Chip8::loadGame(const char* path)
{
    FILE* game = fopen(path, "rb");
    if (game == nullptr)
    {
        printf("Cannot open the file: %s\n", path);
        return false;
    }

    fseek(game, 0, SEEK_END);
    long gameSize = ftell(game);
    fseek(game, 0, SEEK_SET);

    if (gameSize < 0 || gameSize > (4096 - 0x200))
    {
        printf("The game size is invalid\n");
        fclose(game);
        return false;
    }

    size_t result = fread(memory + 0x200, 1, (size_t)gameSize, game);

    if (result != (size_t)gameSize)
    {
        printf("ERROR while reading the file\n");
        fclose(game);
        return false;
    }

    fclose(game);
    printf("Successed reading the file\n");
    return true;
}

void Chip8::emulate()
{
    // Fetch opcode
    opcode = memory[pc] << 8 | memory[pc + 1];

    // Bug fix: 연산자 우선순위 — >> 가 & 보다 우선순위 높음
    //   잘못된 예: opcode & 0x0F00 >> 8  →  opcode & (0x0F00 >> 8)  =  opcode & 0x0F
    //   올바른 예: (opcode & 0x0F00) >> 8
    // 반복 사용을 줄이기 위해 미리 추출
    uint8_t  X   = (opcode & 0x0F00) >> 8;
    uint8_t  Y   = (opcode & 0x00F0) >> 4;
    uint8_t  NN  =  opcode & 0x00FF;
    uint16_t NNN =  opcode & 0x0FFF;

    switch (opcode & 0xF000)
    {
    case 0x0000:
        // Bug fix: 0x000F → 0x00FF 로 마스킹해야 00E0 / 00EE 를 명확히 구분
        switch (opcode & 0x00FF)
        {
        // 00E0 - Clear screen
        case 0x00E0:
            memset(gfx, 0, sizeof(gfx));
            drawFlag = true;
            pc += 2;
            break;
        // 00EE - Return from subroutine
        // Bug fix: 2NNN 에서 pc+2 를 저장하도록 수정했으므로 여기서는 그냥 pop
        case 0x00EE:
            pc = stack[--sp];
            break;
        default:
            printf("Unknown opcode: 0x%04X\n", opcode);
            break;
        }
        break;

    // 1NNN - Jump to NNN
    case 0x1000:
        pc = NNN;
        break;

    // 2NNN - Call subroutine at NNN
    // Bug fix: sizeof(stack) = 32 (bytes) 이므로 스택 개수 비교는 16 으로
    // Bug fix: 복귀 주소로 pc 가 아닌 pc+2 를 저장 (pc 저장 시 00EE 가 call 명령으로 돌아가 무한루프)
    case 0x2000:
        if (sp < 16)
            stack[sp++] = pc + 2;
        else
            printf("Stack overflow\n");
        pc = NNN;
        break;

    // 3XNN - Skip next if VX == NN
    case 0x3000:
        pc += (V[X] == NN) ? 4 : 2;
        break;

    // 4XNN - Skip next if VX != NN
    case 0x4000:
        pc += (V[X] != NN) ? 4 : 2;
        break;

    // 5XY0 - Skip next if VX == VY
    case 0x5000:
        pc += (V[X] == V[Y]) ? 4 : 2;
        break;

    // 6XNN - VX = NN
    case 0x6000:
        V[X] = NN;
        pc += 2;
        break;

    // 7XNN - VX += NN (carry flag 없음)
    // Bug fix: pc += 2 누락
    case 0x7000:
        V[X] += NN;
        pc += 2;
        break;

    // 8XYN - Arithmetic / Logic
    case 0x8000:
        switch (opcode & 0x000F)
        {
        // 8XY0 - VX = VY
        case 0x0000:
            V[X] = V[Y];
            pc += 2;
            break;

        // 8XY1 - VX |= VY
        case 0x0001:
            V[X] |= V[Y];
            pc += 2;
            break;

        // 8XY2 - VX &= VY
        case 0x0002:
            V[X] &= V[Y];
            pc += 2;
            break;

        // 8XY3 - VX ^= VY
        case 0x0003:
            V[X] ^= V[Y];
            pc += 2;
            break;

        // 8XY4 - VX += VY, VF = carry
        case 0x0004:
            V[0xF] = (V[X] > 0xFF - V[Y]) ? 1 : 0;
            V[X] += V[Y];
            pc += 2;
            break;

        // 8XY5 - VX -= VY, VF = 1 if no borrow (VX >= VY)
        case 0x0005:
            V[0xF] = (V[X] >= V[Y]) ? 1 : 0;
            V[X] -= V[Y];
            pc += 2;
            break;

        // 8XY6 - VX >>= 1, VF = LSB before shift
        case 0x0006:
            V[0xF] = V[X] & 0x1;
            V[X] >>= 1;
            pc += 2;
            break;

        // 8XY7 - VX = VY - VX, VF = 1 if no borrow (VY >= VX)
        case 0x0007:
            V[0xF] = (V[Y] >= V[X]) ? 1 : 0;
            V[X] = V[Y] - V[X];
            pc += 2;
            break;

        // 8XYE - VX <<= 1, VF = MSB before shift
        // Bug fix: V[0x0F00 >> 8] = V[15] = VF 를 시프트하던 버그 → V[X] 로 수정
        case 0x000E:
            V[0xF] = (V[X] & 0x80) >> 7;
            V[X] <<= 1;
            pc += 2;
            break;

        default:
            printf("Unknown opcode: 0x%04X\n", opcode);
            break;
        }
        break; // Bug fix: break 누락 → 0x9000 으로 fallthrough 하던 버그

    // 9XY0 - Skip next if VX != VY
    case 0x9000:
        pc += (V[X] != V[Y]) ? 4 : 2;
        break;

    // ANNN - I = NNN
    case 0xA000:
        I = NNN;
        pc += 2;
        break;

    // BNNN - Jump to V0 + NNN (subroutine call 이 아닌 단순 jump)
    // Bug fix: stack push 제거 (BNNN 은 call 이 아님)
    // Bug fix: V[0] + opcode & 0x0FFF → (V[0] + opcode) & 0x0FFF 가 되던 우선순위 버그
    case 0xB000:
        pc = V[0] + NNN;
        break;

    // CXNN - VX = random(0~255) & NN
    case 0xC000:
        V[X] = (rand() % 256) & NN;
        pc += 2;
        break;

    // DXYN - Draw sprite at (VX, VY), height N rows, XOR onto gfx
    case 0xD000:
    {
        uint8_t x      = V[X];
        uint8_t y      = V[Y];
        uint8_t height = opcode & 0x000F;

        V[0xF] = 0;
        for (int yline = 0; yline < height; yline++)
        {
            uint8_t row = memory[I + yline];
            for (int xline = 0; xline < 8; xline++)
            {
                if ((row & (0x80 >> xline)) != 0)
                {
                    // 화면 경계 wrapping
                    int idx = ((x + xline) % 64) + ((y + yline) % 32) * 64;
                    if (gfx[idx] == 1)
                        V[0xF] = 1; // collision
                    gfx[idx] ^= 1;
                }
            }
        }

        drawFlag = true;
        pc += 2;
    }
    break;

    // EXNN - Key operations
    case 0xE000:
        switch (opcode & 0x00FF)
        {
        // EX9E - Skip next if key[VX] is pressed
        case 0x009E:
            pc += key[V[X]] ? 4 : 2;
            break;

        // EXA1 - Skip next if key[VX] is NOT pressed
        case 0x00A1:
            pc += !key[V[X]] ? 4 : 2;
            break;

        default:
            printf("Unknown opcode: 0x%04X\n", opcode);
            break;
        }
        break;

    case 0xF000:
        switch (opcode & 0x00FF)
        {
        // FX07 - VX = delay_timer
        case 0x0007:
            V[X] = delay_timer;
            pc += 2;
            break;

        // FX0A - Wait for key press (blocking), store key index in VX
        case 0x000A:
        {
            bool pressed = false;
            for (int i = 0; i < 16; i++)
            {
                if (key[i])
                {
                    V[X] = i;
                    pressed = true;
                    break;
                }
            }
            // 키가 눌리지 않으면 pc를 증가시키지 않고 다음 사이클에서 재시도
            if (!pressed)
                return;
            pc += 2;
        }
        break;

        // FX15 - delay_timer = VX
        case 0x0015:
            delay_timer = V[X];
            pc += 2;
            break;

        // FX18 - sound_timer = VX
        // Bug fix: break 누락으로 FX1E 로 fallthrough 하던 버그
        case 0x0018:
            sound_timer = V[X];
            pc += 2;
            break;

        // FX1E - I += VX
        case 0x001E:
            I += V[X];
            pc += 2;
            break;

        // FX29 - I = sprite address for digit VX (fontset, 각 글자 5바이트)
        case 0x0029:
            I = V[X] * 5;
            pc += 2;
            break;

        // FX33 - BCD of VX → memory[I], memory[I+1], memory[I+2]
        case 0x0033:
            memory[I]     = V[X] / 100;
            memory[I + 1] = (V[X] / 10) % 10;
            memory[I + 2] = V[X] % 10;
            pc += 2;
            break;

        // FX55 - Store V0..VX into memory starting at I
        case 0x0055:
            for (int i = 0; i <= X; i++)
                memory[I + i] = V[i];
            pc += 2;
            break;

        // FX65 - Load V0..VX from memory starting at I
        case 0x0065:
            for (int i = 0; i <= X; i++)
                V[i] = memory[I + i];
            pc += 2;
            break;

        default:
            printf("Unknown opcode: 0x%04X\n", opcode);
            break;
        }
        break;

    default:
        printf("Unknown opcode: 0x%04X\n", opcode);
        break;
    }

}

// 메인 루프에서 60Hz 로 한 번씩 호출
void Chip8::tickTimers()
{
    if (delay_timer > 0)
        --delay_timer;

    soundFlag = (sound_timer > 0);
    if (sound_timer > 0)
        --sound_timer;
}