Tetris is now fully playable!

Author: ByteOfMelon

CMakeLists.txt

@@ -42,6 +42,7 @@ add_executable(GameByte src/main.cpp
                           src/core/mmu.cpp
                           src/core/rom.cpp
                           src/core/ppu.cpp
+                          src/core/joypad.cpp
                           # Add other.cpp files as you create them
                           )
 

README.md

@@ -23,4 +23,20 @@ GameByte uses a standard CMake file to do its builds. Currently, builds are offi
 You can build with a regular CMake build command, or utilize the VS Code launch tasks to quickly build and run the project in debug mode.
 
 # Running
-You will need to provide your own Tetris ROM file from a legal source and place it alongside the executable in a file called `tetris.gb`. GameByte will only work with Tetris currently.
+You will need to provide your own Tetris ROM file from a legal source and place it alongside the executable in a file called `tetris.gb`. GameByte will only work with Tetris currently.
+
+# Compatibility
+GameByte is a research emulator that is not intended to be fully accurate or usable with a lot of Game Boy games. However, a compatibility list showing tested games are listed below.
+
+## States
+- **Playable** - Games that can be completed with playable performance and no game breaking glitches
+- **Ingame** - Games that can get in-game but cannot be finished, have serious glitches or insufficient performance
+- **Menus** - Games that initially run but cannot go ingame
+- **Nothing** - Games that do not initialize properly and/or do not load
+
+## Compatibility List
+
+| **Game Title**   | **Publisher** | **Year** | **State** |
+|------------------|---------------|----------|-----------|
+| Tetris           | Nintendo      | 1989     | Playable  |
+| Every other game | Anyone        | Any time | Nothing   |

src/core/cpu.cpp

@@ -518,6 +518,7 @@ void CPU::init_instructions() {
     instructions[0x7C] = { "LD A, H", &CPU::LD_A_H };
     instructions[0x7D] = { "LD A, L", &CPU::LD_A_L };
 
+    instructions[0xB7] = { "OR A, A", &CPU::OR_A_A };
     instructions[0xB0] = { "OR A, B", &CPU::OR_A_B };
     instructions[0xB1] = { "OR A, C", &CPU::OR_A_C };
     instructions[0xB2] = { "OR A, D", &CPU::OR_A_D };
@@ -543,9 +544,16 @@ void CPU::init_instructions() {
     instructions[0xE6] = { "AND A, n8", &CPU::AND_A_n8 };
 
     instructions[0x28] = { "JR Z, e8", &CPU::JR_Z_e8 };
+
+    instructions[0x30] = { "JR NC, e8", &CPU::JR_NC_e8 };
+    instructions[0x38] = { "JR C, e8", &CPU::JR_C_e8 };
+
     instructions[0xC0] = { "RET NZ", &CPU::RET_NZ };
     instructions[0xC8] = { "RET Z", &CPU::RET_Z };
 
+    instructions[0xD0] = { "RET NC", &CPU::RET_NC };
+    instructions[0xD8] = { "RET C", &CPU::RET_C };
+
     instructions[0xE1] = { "POP HL", &CPU::POP_HL };
     instructions[0xC1] = { "POP BC", &CPU::POP_BC };
     instructions[0xD1] = { "POP DE", &CPU::POP_DE };
@@ -660,6 +668,9 @@ void CPU::init_instructions() {
     instructions[0x73] = { "LD (HL), E", &CPU::LD_at_HL_E };
     instructions[0x74] = { "LD (HL), H", &CPU::LD_at_HL_H };
     instructions[0x75] = { "LD (HL), L", &CPU::LD_at_HL_L };
+
+    instructions[0x07] = { "RLCA", &CPU::RLCA };
+    instructions[0x27] = { "DAA", &CPU::DAA };
 }
 
 uint8_t CPU::XXX() {
@@ -1354,6 +1365,16 @@ uint8_t CPU::LD_A_A() {
     return 4;
 }
 
+uint8_t CPU::OR_A_A() {
+    a |= a;
+    set_flag_z(a == 0);
+    set_flag_n(false);
+    set_flag_h(false);
+    set_flag_c(false);
+
+    return 4;
+}
+
 uint8_t CPU::OR_A_B() {
     a |= b;
     set_flag_z(a == 0);
@@ -1542,6 +1563,30 @@ uint8_t CPU::JR_Z_e8() {
     return 8;
 }
 
+uint8_t CPU::JR_C_e8() {
+    int8_t offset = static_cast<int8_t>(mmu->read_byte(pc));
+    pc++;
+
+    if (get_flag_c()) {
+        pc += offset;
+        return 12;
+    }
+    
+    return 8;
+}
+
+uint8_t CPU::JR_NC_e8() {
+    int8_t offset = static_cast<int8_t>(mmu->read_byte(pc));
+    pc++;
+
+    if (!get_flag_c()) {
+        pc += offset;
+        return 12;
+    }
+    
+    return 8;
+}
+
 uint8_t CPU::RET_NZ() {
     if (!get_flag_z()) {
         // Pop address from stack into PC
@@ -1564,6 +1609,30 @@ uint8_t CPU::RET_Z() {
     return 8;
 }
 
+uint8_t CPU::RET_NC() {
+    if (!get_flag_c()) {
+        // Pop address from stack into PC
+        pc = mmu->read_word(sp);
+        sp += 2;
+
+        return 20;
+    } else {
+        return 8;
+    }
+}
+
+uint8_t CPU::RET_C() {
+    if (get_flag_c()) {
+        // Pop address from stack into PC
+        pc = mmu->read_word(sp);
+        sp += 2;
+
+        return 20;
+    } else {
+        return 8;
+    }
+}
+
 uint8_t CPU::LD_A_BC_ptr() {
     a = mmu->read_byte(get_bc());
     return 8;
@@ -2247,4 +2316,55 @@ uint8_t CPU::LD_at_HL_L() {
     mmu->write_byte(address, l);
 
     return 8;
+}
+
+uint8_t CPU::RLCA() {
+    // Find bit 7 and rotate it
+    uint8_t bit7 = (a & 0x80) >> 7;
+    a = (a << 1) | bit7;
+
+    set_flag_z(false);
+    set_flag_n(false);
+    set_flag_h(false);
+    set_flag_c(bit7 == 1);
+
+    return 4;
+}
+
+uint8_t CPU::DAA() {
+    uint8_t adjustment = 0;
+    bool new_carry = false;
+
+    if (!get_flag_n()) {
+        // After an ADD operation
+        if (get_flag_c() || a > 0x99) {
+            adjustment |= 0x60;
+            new_carry = true;
+        }
+        if (get_flag_h() || (a & 0x0F) > 0x09) {
+            adjustment |= 0x06;
+        }
+    } else {
+        // After a SUB operation
+        if (get_flag_c()) {
+            adjustment |= 0x60;
+            new_carry = true;
+        }
+        if (get_flag_h()) {
+            adjustment |= 0x06;
+        }
+        
+        // Subtract the adjustment instead of adding it
+        a -= adjustment;
+    }
+
+    if (!get_flag_n()) {
+        a += adjustment;
+    }
+
+    set_flag_z(a == 0);
+    set_flag_h(false);
+    set_flag_c(new_carry);
+
+    return 4;
 }

src/core/cpu.h

@@ -296,6 +296,9 @@ class CPU {
         // Copy 8-bit value from A register to A register (0x7F)
         uint8_t LD_A_A();
 
+        // Bitwise OR with A and A register, result in A (0xB7)
+        uint8_t OR_A_A();
+
         // Bitwise OR with A and B register, result in A (0xB0)
         uint8_t OR_A_B();
 
@@ -359,12 +362,24 @@ class CPU {
         // Jump relative if zero flag set (0x28)
         uint8_t JR_Z_e8();
 
+        // Jump relative if carry flag not set (0x30)
+        uint8_t JR_NC_e8();
+
+        // Jump relative if carry flag set (0x38)
+        uint8_t JR_C_e8();
+
         // Return from subroutine if zero flag not set (0xC0)
         uint8_t RET_NZ();
 
         // Return from subroutine if zero flag set (0xC8)
         uint8_t RET_Z();
 
+        // Return from subroutine if carry flag not set (0xD0)
+        uint8_t RET_NC();
+
+        // Return from subroutine if carry flag set (0xD8)
+        uint8_t RET_C();
+
         // Load A Indirect Group
         uint8_t LD_A_BC_ptr(); // 0x0A
         uint8_t LD_A_DE_ptr(); // 0x1A
@@ -554,6 +569,12 @@ class CPU {
 
         // Write value of register L into address pointed to by HL (0x75)
         uint8_t LD_at_HL_L();
+
+        // Rotate A register left circular (0x07)
+        uint8_t RLCA();
+
+        // Decimal Adjust Accumulator (0x27)
+        uint8_t DAA();
     private:
         // Performs addition (ADD/ADC) and updates flags
         // carry: if true, adds the C flag to the sum

src/core/joypad.cpp

@@ -0,0 +1,54 @@
+#include "joypad.h"
+
+uint8_t Joypad::get_joyp_state() {
+    uint8_t res = 0xC0 | control_mask;
+    uint8_t buttons = 0x0F;
+
+    // Direction keys selected (Bit 4 is 0)
+    if (!(control_mask & 0x10)) {
+        buttons &= direction_buttons;
+    }
+
+    // Action keys selected (Bit 5 is 0)
+    if (!(control_mask & 0x20)) {
+        buttons &= action_buttons;
+    }
+    
+    return (res & 0xF0) | (buttons & 0x0F);
+}
+
+bool Joypad::handle_sdl_event(const SDL_Event& e) {
+    if (e.type != SDL_EVENT_KEY_DOWN && e.type != SDL_EVENT_KEY_UP) return false;
+
+    bool pressed = (e.type == SDL_EVENT_KEY_DOWN);
+    SDL_Keycode key = e.key.key;
+    bool interrupt_needed = false;
+
+    auto update_bit = [&](uint8_t& buttons, int bit, bool is_pressed) {
+        if (is_pressed) {
+            // If the button was previously NOT pressed (bit was 1), trigger interrupt
+            if (buttons & (1 << bit)) interrupt_needed = true;
+            buttons &= ~(1 << bit);
+        } else {
+            buttons |= (1 << bit);
+        }
+    };
+
+    switch (key) {
+        // Directions
+        case SDLK_RIGHT:  update_bit(direction_buttons, 0, pressed); break;
+        case SDLK_LEFT:   update_bit(direction_buttons, 1, pressed); break;
+        case SDLK_UP:     update_bit(direction_buttons, 2, pressed); break;
+        case SDLK_DOWN:   update_bit(direction_buttons, 3, pressed); break;
+
+        // Actions
+        case SDLK_Z:      update_bit(action_buttons, 0, pressed);    break; // A
+        case SDLK_X:      update_bit(action_buttons, 1, pressed);    break; // B
+        case SDLK_RSHIFT: update_bit(action_buttons, 2, pressed);    break; // Select
+        case SDLK_RETURN: update_bit(action_buttons, 3, pressed);    break; // Start
+
+        default: break;
+    }
+
+    return interrupt_needed;
+}

src/core/joypad.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <cstdint>
+#include <SDL3/SDL.h>
+
+class Joypad {
+    public:
+        // Button states (0 = pressed, 1 = released)
+        uint8_t action_buttons = 0x0F;    // Start, Select, B, A
+        uint8_t direction_buttons = 0x0F; // Down, Up, Left, Right
+        
+        // The value written by the CPU to $FF00 to select which buttons to read
+        uint8_t control_mask = 0x30; 
+
+        // Get current state of the joypad register ($FF00)
+        uint8_t get_joyp_state();
+
+        // Handles SDL events and returns true if a Joypad Interrupt (bit 4) should be requested
+        bool handle_sdl_event(const SDL_Event& event);
+};

src/core/mmu.cpp

@@ -1,6 +1,7 @@
 #include "mmu.h"
 #include "cpu.h"
 #include "ppu.h"
+#include "joypad.h"
 #include <cstring>
 #include <iostream>
 #include <sstream>
@@ -26,13 +27,17 @@ void MMU::connect_ppu(PPU* p) {
     ppu = p;
 }
 
+void MMU::connect_joypad(Joypad* j) {
+    joypad = j;
+}
+
 bool MMU::load_game(const uint8_t* data, size_t size) {
     // Clear cartridge memory
     memset(cart, 0, sizeof(cart));
 
     if (size > sizeof(cart)) {
         // For now, if ROM is larger than 32KB, throw an error. In the future this needs to be handled by MBC logic.
-        throw std::runtime_error("[MMU] ERROR: ROM size (" + std::to_string(size) + ") larger than 32KB. Bank switching is not currently supported.");
+        throw std::runtime_error("[MMU] ERROR: ROM size (" + std::to_string(size) + ") larger than 32KB. Bank switching/MBC logic is not currently supported.");
         std::memcpy(cart, data, sizeof(cart));
     } else {
         std::memcpy(cart, data, size);
@@ -67,8 +72,8 @@ uint8_t MMU::read_byte(uint16_t address) {
     } else if (address >= 0xFF00 && address <= 0xFF7F) {
         // Joypad (0xFF00)
         if (address == 0xFF00) {
-            return 0xFF; // No keys pressed (Active Low)
-        }
+            return joypad ? joypad->get_joyp_state() : 0xFF;
+        }   
 
         // I/O Registers
         if (address == 0xFF04 && cpu) {
@@ -108,6 +113,15 @@ void MMU::write_byte(uint16_t address, uint8_t value) {
     std::stringstream ss;
 
     // Special write cases (i.e. I/O registers, VRAM, etc)
+    // Joypad
+    if (address == 0xFF00) {
+        if (joypad) {
+            // Only bits 4 and 5 are writable by the CPU
+            joypad->control_mask = (value & 0x30);
+        }
+        return;
+    }
+
     // PPU
     if (address >= 0xFF40 && address <= 0xFF47) {
         // Always update the I/O memory map so reads (like in PPU::draw_scanline) get the correct value

src/core/mmu.h

@@ -7,6 +7,7 @@
 
 class CPU;
 class PPU;
+class Joypad;
 
 /**
  * @brief Implements the Game Boy's Memory Management Unit (MMU).alignas
@@ -37,6 +38,9 @@ class MMU {
         PPU* ppu = nullptr;
         void connect_ppu(PPU* p);
 
+        Joypad* joypad = nullptr;
+        void connect_joypad(Joypad* j);
+
         uint8_t read_byte(uint16_t address);
         void write_byte(uint16_t address, uint8_t value);