snake game running from ROM. tests broken

Author: nathanleiby

src/bus.rs

@@ -1,44 +1,42 @@
-use crate::core::Mem;
+use crate::{core::Mem, rom::Rom};
 
 const RAM: u16 = 0x0000;
 const RAM_MIRROR_END: u16 = 0x2000;
 
 const PPU: u16 = 0x2000;
 const PPU_MIRROR_END: u16 = 0x4000;
 
+pub const PRG_ROM_START: u16 = 0x8000;
+const PRG_ROM_END: u16 = 0xFFFF;
+
 pub struct Bus {
     cpu_vram: [u8; 0x800], // 2048
-
-    // TODO: This was needed to get my tests working again after Ch4
-    // https://bugzmanov.github.io/nes_ebook/chapter_4.html
-    // Did the author have another approach? I couldn't find it in repo.
-    // fallback: [u8; 0xffff],
-    program_start1: u8,
-    program_start2: u8,
+    rom: Rom,
+    program_start_1: u8,
+    program_start_2: u8,
 }
 
 impl Bus {
-    pub fn new() -> Self {
+    pub fn new(rom: Rom) -> Self {
         Bus {
             cpu_vram: [0; 0x800],
-            // fallback: [0; 0xffff],
-            program_start1: 0,
-            program_start2: 0,
+            rom,
+            program_start_1: 0,
+            program_start_2: 0,
         }
     }
-}
-
-// TODO: More mappings..
-
-// That RAM is accessible via [0x0000 … 0x2000] address space.
 
-// Access to [0x2000 … 0x4020] is redirected to other available NES hardware modules: PPU, APU, GamePads, etc. (more on this later)
+    fn read_prg_rom(&self, addr: u16) -> u8 {
+        let mut idx = addr - PRG_ROM_START;
 
-// Access to [0x4020 .. 0x6000] is a special space that different generations of cartridges used differently. It might be mapped to RAM, ROM, or nothing at all. The space is controlled by so-called mappers - special circuitry on a cartridge. We will ignore this space.
-
-// Access to [0x6000 .. 0x8000] is reserved to a RAM space on a cartridge if a cartridge has one. It was used in games like Zelda for storing and retrieving the game state. We will ignore this space as well.
+        // If the prg rom is 16KiB (not 32KiB), then we should mirror it
+        if self.rom.prg_rom.len() == 0x4000 {
+            idx %= 0x4000;
+        }
 
-// Access to [0x8000 … 0xFFFF] is mapped to Program ROM (PRG ROM) space on a cartridge.
+        self.rom.prg_rom[idx as usize]
+    }
+}
 
 impl Mem for Bus {
     fn mem_read(&self, addr: u16) -> u8 {
@@ -47,12 +45,15 @@ impl Mem for Bus {
             self.cpu_vram[a as usize]
         } else if (PPU..PPU_MIRROR_END).contains(&addr) {
             todo!("PPU NYI")
-        } else if addr == 0xFFFC {
-            self.program_start1
-        } else if addr == 0xFFFD {
-            self.program_start2
+        } else if (PRG_ROM_START..=PRG_ROM_END).contains(&addr) {
+            // if addr == 0xFFFC {
+            //     self.program_start_1
+            // } else if addr == 0xFFFD {
+            //     self.program_start_2
+            // } else {
+            self.read_prg_rom(addr)
+            // }
         } else {
-            // self.fallback[addr as usize]
             0
         }
     }
@@ -63,10 +64,14 @@ impl Mem for Bus {
             self.cpu_vram[a as usize] = data
         } else if (PPU..PPU_MIRROR_END).contains(&addr) {
             todo!("PPU NYI")
-        } else if addr == 0xFFFC {
-            self.program_start1 = data
-        } else if addr == 0xFFFD {
-            self.program_start2 = data
+        } else if (PRG_ROM_START..=PRG_ROM_END).contains(&addr) {
+            // if addr == 0xFFFC {
+            //     self.program_start_1 = data
+            // } else if addr == 0xFFFD {
+            //     self.program_start_2 = data
+            // } else {
+            panic!("attempt to write to ROM cartridge")
+            // }
         } else {
             // self.fallback[addr as usize] = data
         };
@@ -79,7 +84,8 @@ mod tests {
 
     #[test]
     fn test_read_mirroring() {
-        let mut bus = Bus::new();
+        let rom = Rom::new_test();
+        let mut bus = Bus::new(rom);
         bus.cpu_vram[0] = 123;
 
         assert_eq!(bus.mem_read(0), 123);
@@ -90,7 +96,8 @@ mod tests {
 
     #[test]
     fn test_write_mirroring() {
-        let mut bus = Bus::new();
+        let rom = Rom::new_test();
+        let mut bus = Bus::new(rom);
 
         bus.mem_write(0, 1);
         assert_eq!(bus.cpu_vram[0], 1);

src/core.rs

@@ -1,4 +1,7 @@
-use crate::bus::Bus;
+use crate::{
+    bus::{Bus, PRG_ROM_START},
+    rom::Rom,
+};
 
 /// CPU (Central Processing Unit)
 /// The NES uses  2A03, which is a modified version of the 6502 chip.
@@ -92,17 +95,22 @@ impl Mem for Cpu {
 
 impl Cpu {
     pub fn new() -> Self {
+        let rom = Rom::new_test();
         Cpu {
             pc: 0,
             sp: 0xff,
             a: 0,
             x: 0,
             y: 0,
             status: 0,
-            bus: Bus::new(),
+            bus: Bus::new(rom),
         }
     }
 
+    pub fn set_bus(&mut self, bus: Bus) {
+        self.bus = bus
+    }
+
     //
     // STACK
     //
@@ -181,12 +189,22 @@ impl Cpu {
 
     // load method should load a program into PRG ROM space and save the reference to the code into 0xFFFC memory cell
     pub fn load(&mut self, program: Vec<u8>) {
-        for (i, val) in program.iter().enumerate() {
-            self.mem_write((CPU_START + i) as u16, *val);
-        }
-        self.mem_write_u16(0xFFFC, CPU_START as u16);
+        // for (i, val) in program.iter().enumerate() {
+        //     self.mem_write((CPU_START + i) as u16, *val);
+        // }
+        let rom = Rom::new(&program);
+        self.set_bus(Bus::new(rom));
+
+        // TODO: update this to get unit tests working
+        // self.mem_write_u16(0xFFFC, CPU_START as u16);
     }
 
+    // pub fn load_rom(&mut self, rom: Rom) {
+    //     // Load turns program into ROM, then sets the bus
+    //     self.set_bus(Bus::new(rom));
+    //     // self.mem_write_u16(0xFFFC, CPU_START as u16);
+    // }
+
     fn load_and_run(&mut self, program: Vec<u8>) {
         self.load(program);
         self.reset();
@@ -222,10 +240,10 @@ impl Cpu {
                 0,
                 op
             );
-            // println!(
-            //     "\ta={:#06x} x={:#06x} y={:#06x} flags={:#010b}",
-            //     self.a, self.x, self.y, self.status,
-            // );
+            println!(
+                "\ta={:#06x} x={:#06x} y={:#06x} flags={:#010b}",
+                self.a, self.x, self.y, self.status,
+            );
             self.pc += 1;
             match op {
                 // LDA
@@ -1280,7 +1298,9 @@ mod tests {
     #[test]
     fn test_0xa0_lda_immediate_nonzero() {
         let mut cpu = Cpu::new();
-        cpu.load_and_run(vec![0xa9, 0x55, 0x00]);
+        cpu.load_rom(Rom::new_test_rom(vec![0xa9, 0x55, 0x00]));
+        cpu.reset();
+        cpu.run();
         assert_eq!(cpu.a, 0x55);
         assert_eq!(cpu.status, 0b0000_0000);
     }

src/main.rs

@@ -1,46 +1,24 @@
 use core::Cpu;
 use core::Mem;
 use std::error::Error;
+use std::fs;
 use std::thread::sleep;
 use std::time::Duration;
 
 mod bus;
 mod core;
 mod rom;
 
+use bus::Bus;
 use rand::random;
+use rom::Rom;
 use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
 use sdl2::pixels::Color;
 use sdl2::pixels::PixelFormatEnum;
 use sdl2::EventPump;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    // snake game, for basic testing
-    let program = vec![
-        0x20, 0x06, 0x06, 0x20, 0x38, 0x06, 0x20, 0x0d, 0x06, 0x20, 0x2a, 0x06, 0x60, 0xa9, 0x02,
-        0x85, 0x02, 0xa9, 0x04, 0x85, 0x03, 0xa9, 0x11, 0x85, 0x10, 0xa9, 0x10, 0x85, 0x12, 0xa9,
-        0x0f, 0x85, 0x14, 0xa9, 0x04, 0x85, 0x11, 0x85, 0x13, 0x85, 0x15, 0x60, 0xa5, 0xfe, 0x85,
-        0x00, 0xa5, 0xfe, 0x29, 0x03, 0x18, 0x69, 0x02, 0x85, 0x01, 0x60, 0x20, 0x4d, 0x06, 0x20,
-        0x8d, 0x06, 0x20, 0xc3, 0x06, 0x20, 0x19, 0x07, 0x20, 0x20, 0x07, 0x20, 0x2d, 0x07, 0x4c,
-        0x38, 0x06, 0xa5, 0xff, 0xc9, 0x77, 0xf0, 0x0d, 0xc9, 0x64, 0xf0, 0x14, 0xc9, 0x73, 0xf0,
-        0x1b, 0xc9, 0x61, 0xf0, 0x22, 0x60, 0xa9, 0x04, 0x24, 0x02, 0xd0, 0x26, 0xa9, 0x01, 0x85,
-        0x02, 0x60, 0xa9, 0x08, 0x24, 0x02, 0xd0, 0x1b, 0xa9, 0x02, 0x85, 0x02, 0x60, 0xa9, 0x01,
-        0x24, 0x02, 0xd0, 0x10, 0xa9, 0x04, 0x85, 0x02, 0x60, 0xa9, 0x02, 0x24, 0x02, 0xd0, 0x05,
-        0xa9, 0x08, 0x85, 0x02, 0x60, 0x60, 0x20, 0x94, 0x06, 0x20, 0xa8, 0x06, 0x60, 0xa5, 0x00,
-        0xc5, 0x10, 0xd0, 0x0d, 0xa5, 0x01, 0xc5, 0x11, 0xd0, 0x07, 0xe6, 0x03, 0xe6, 0x03, 0x20,
-        0x2a, 0x06, 0x60, 0xa2, 0x02, 0xb5, 0x10, 0xc5, 0x10, 0xd0, 0x06, 0xb5, 0x11, 0xc5, 0x11,
-        0xf0, 0x09, 0xe8, 0xe8, 0xe4, 0x03, 0xf0, 0x06, 0x4c, 0xaa, 0x06, 0x4c, 0x35, 0x07, 0x60,
-        0xa6, 0x03, 0xca, 0x8a, 0xb5, 0x10, 0x95, 0x12, 0xca, 0x10, 0xf9, 0xa5, 0x02, 0x4a, 0xb0,
-        0x09, 0x4a, 0xb0, 0x19, 0x4a, 0xb0, 0x1f, 0x4a, 0xb0, 0x2f, 0xa5, 0x10, 0x38, 0xe9, 0x20,
-        0x85, 0x10, 0x90, 0x01, 0x60, 0xc6, 0x11, 0xa9, 0x01, 0xc5, 0x11, 0xf0, 0x28, 0x60, 0xe6,
-        0x10, 0xa9, 0x1f, 0x24, 0x10, 0xf0, 0x1f, 0x60, 0xa5, 0x10, 0x18, 0x69, 0x20, 0x85, 0x10,
-        0xb0, 0x01, 0x60, 0xe6, 0x11, 0xa9, 0x06, 0xc5, 0x11, 0xf0, 0x0c, 0x60, 0xc6, 0x10, 0xa5,
-        0x10, 0x29, 0x1f, 0xc9, 0x1f, 0xf0, 0x01, 0x60, 0x4c, 0x35, 0x07, 0xa0, 0x00, 0xa5, 0xfe,
-        0x91, 0x00, 0x60, 0xa6, 0x03, 0xa9, 0x00, 0x81, 0x10, 0xa2, 0x00, 0xa9, 0x01, 0x81, 0x10,
-        0x60, 0xa2, 0x00, 0xea, 0xea, 0xca, 0xd0, 0xfb, 0x60,
-    ];
-
     let sdl_context = sdl2::init()?;
     let video_subsystem = sdl_context.video()?;
     let window = video_subsystem
@@ -57,6 +35,9 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let mut screen_state = [0_u8; 32 * 3 * 32];
 
+    // snake game, for basic testing
+    let program = fs::read("roms/snake.nes").unwrap();
+
     let mut cpu = Cpu::new();
     cpu.load(program);
     cpu.reset();

src/rom.rs

@@ -11,14 +11,14 @@ enum Mapper {
 }
 
 pub struct Rom {
-    prg_rom: Vec<u8>,
+    pub prg_rom: Vec<u8>,
     chr_rom: Vec<u8>,
     mapper: Mapper,
     mirroring: Mirroring,
 }
 
-const CHR_ROM_PAGE_SIZE: usize = 256;
-const PRG_ROM_PAGE_SIZE: usize = 256;
+const PRG_ROM_PAGE_SIZE: usize = 16384;
+const CHR_ROM_PAGE_SIZE: usize = 8192;
 
 impl Rom {
     pub fn new(bytes: &[u8]) -> Self {
@@ -39,7 +39,7 @@ impl Rom {
         let control_byte_2 = header[7];
         // let size_of_prg_ram_times_8kb = header[8];
 
-        let has_trainer_bytes = control_byte_1 ^ (1 << 2) > 0;
+        let has_trainer_bytes = control_byte_1 ^ (1 << 2) == 0;
         let is_four_screen = control_byte_1 & (1 << 3) > 0;
         let is_vertical_screen = control_byte_1 & 1 > 0;
 
@@ -76,6 +76,38 @@ impl Rom {
             mirroring,
         }
     }
+
+    pub fn new_test() -> Self {
+        let mut prg_rom = [0; 0x8000].to_vec();
+        // prg_rom[0xFFFC - 0x8000] = CPU_START
+        // prg_rom[0xFFFC - 0x8000] = CPU_START
+        Self {
+            prg_rom: vec![],
+            chr_rom: vec![],
+            mapper: Mapper::Zero,
+            mirroring: Mirroring::Vertical,
+        }
+    }
+
+    pub(crate) fn new_test_rom(vec: Vec<u8>) -> Rom {
+        let mut prg_rom: Vec<u8> = [0; 0x8000].to_vec();
+        let program_start = 0x600;
+        for (idx, b) in vec.iter().enumerate() {
+            prg_rom[program_start + idx] = *b;
+        }
+
+        prg_rom[0xFFFC - 0x8000] = 0x00;
+        prg_rom[0xFFFD - 0x8000] = 0x86;
+
+        println!("{:?}", &prg_rom[0x600..0x640]);
+
+        Self {
+            prg_rom,
+            chr_rom: vec![],
+            mapper: Mapper::Zero,
+            mirroring: Mirroring::Vertical,
+        }
+    }
 }
 
 #[cfg(test)]