reading from ROM in .nes file

Author: nathanleiby

roms/snake.nes

@@ -28,6 +28,18 @@ impl Bus {
     }
 }
 
+// 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)
+
+// 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.
+
+// Access to [0x8000 … 0xFFFF] is mapped to Program ROM (PRG ROM) space on a cartridge.
+
 impl Mem for Bus {
     fn mem_read(&self, addr: u16) -> u8 {
         if (RAM..RAM_MIRROR_END).contains(&addr) {

src/bus.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 
 mod bus;
 mod core;
+mod rom;
 
 use rand::random;
 use sdl2::event::Event;

src/main.rs

@@ -0,0 +1,96 @@
+#[derive(PartialEq, Eq, Debug)]
+enum Mirroring {
+    FourScreen,
+    Vertical,
+    Horizontal,
+}
+
+#[derive(PartialEq, Eq, Debug)]
+enum Mapper {
+    Zero,
+}
+
+pub struct Rom {
+    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;
+
+impl Rom {
+    pub fn new(bytes: &[u8]) -> Self {
+        if bytes.len() < 16 {
+            panic!("invalid rom: less than 16 bytes long")
+        }
+        let header = &bytes[0..16];
+
+        // check if NES^Z is set
+        let nes_file_prefix: [u8; 4] = [0x4E, 0x45, 0x53, 0x1A];
+        if !header[0..4].eq(&nes_file_prefix) {
+            panic!("invalid rom: lacks the 'NES^Z' prefix")
+        }
+
+        let prg_rom_banks = header[4];
+        let chr_rom_banks = header[5];
+        let control_byte_1 = header[6];
+        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 is_four_screen = control_byte_1 & (1 << 3) > 0;
+        let is_vertical_screen = control_byte_1 & 1 > 0;
+
+        let lo = (control_byte_1 & 0b1111_0000) >> 4;
+        let hi = control_byte_2 & 0b1111_0000;
+        let rom_mapper_type = hi + lo;
+
+        let mapper = match rom_mapper_type {
+            0 => Mapper::Zero,
+            _ => todo!(),
+        };
+
+        let mirroring = match (is_four_screen, is_vertical_screen) {
+            (true, _) => Mirroring::FourScreen,
+            (false, true) => Mirroring::Vertical,
+            (false, false) => Mirroring::Horizontal,
+        };
+
+        let prg_rom_len = (prg_rom_banks as usize) * PRG_ROM_PAGE_SIZE;
+        let chr_rom_len = (chr_rom_banks as usize) * CHR_ROM_PAGE_SIZE;
+
+        let header_size: usize = 16;
+        let trainer_size = if has_trainer_bytes { 512 } else { 0 };
+        let prg_rom_start = header_size + trainer_size;
+        let prg_rom: Vec<u8> = bytes[prg_rom_start..prg_rom_start + prg_rom_len].to_vec();
+
+        let chr_rom_start = prg_rom_start + prg_rom_len;
+        let chr_rom = bytes[chr_rom_start..chr_rom_start + chr_rom_len].to_vec();
+
+        Rom {
+            prg_rom,
+            chr_rom,
+            mapper,
+            mirroring,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::fs;
+
+    use super::*;
+
+    #[test]
+    fn test_snake_rom_from_file() {
+        let contents = fs::read("roms/snake.nes").unwrap();
+        let rom = Rom::new(&contents);
+        assert_eq!(rom.mapper, Mapper::Zero);
+        assert_eq!(rom.mirroring, Mirroring::Vertical);
+        assert_eq!(rom.prg_rom.len(), 2 * PRG_ROM_PAGE_SIZE);
+        assert_eq!(rom.chr_rom.len(), 0);
+    }
+}