diff --git a/README.md b/README.md index a8d85db..0493556 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # nestur -This is an NES emulator and a work in progress. There are still some minor bugs and the audio is kind of scratchy. I've mostly tested on Donkey Kong, Super Mario Bros., and Zelda so far. There are plenty of full-featured emulators out there; this is primarily an educational project but I do want it to run well. SDL2 is the only dependency, it's NTSC timing, and contains no `unsafe` code. +Nestur is an NES emulator and a work in progress. There are still some minor bugs and the audio is kind of scratchy. I've mostly tested on Donkey Kong, Super Mario Bros., and Zelda so far. There are plenty of full-featured emulators out there; this is primarily an educational project but I do want it to run well. SDL2 is the only dependency, it's NTSC timing, and contains no `unsafe` code. @@ -20,13 +20,25 @@ ___________________ ``` The code aims to follow the explanations from the [NES dev wiki](https://wiki.nesdev.com/w/index.php/NES_reference_guide) where possible, especially in the PPU, and the comments quote from it often. Thanks to everyone who contributes to that wiki/forum, and to Michael Fogleman's [NES](https://github.com/fogleman/nes) and Scott Ferguson's [Fergulator](https://github.com/scottferg/Fergulator) for getting me unstuck at several points. +## Compilation and Use + +1. Install Rust: https://www.rust-lang.org/tools/install +2. Configure SDL2 for your platform: + - Windows: `SDL2.dll` is already in the repo so you don't have to do anything. + - macOS: Install [Homebrew](https://brew.sh/) and run `brew install sdl2` + - Linux: `sudo apt-get install libsdl2-dev` (or whatever your package manager is) +3. `cd nestur/ && cargo build --release` +4. The `nestur` executable or `nestur.exe` will be in `nestur/target/release`. +5. Run with `$ ./nestur path/to/rom_filename.nes` or `> nestur.exe path\to\rom_filename.nes`. +6. If the game uses battery-backed RAM (if it can save data when turned off), a save file like `rom_filename.sav` will be created in the same folder as the ROM when the program is exited. When Nestur is run again, it will look for a file matching the ROM name, with a `.sav` extension instead of `.nes`. + ## To do: - More mappers (only mappers 0 (NROM) and 1 (MMC1) implemented so far) - DMC audio channel, high- and low-pass filters -- Save/load functionality and battery-backed RAM solution +- Save state/load functionality - Player 2 controller? diff --git a/src/cartridge/cnrom.rs b/src/cartridge/cnrom.rs new file mode 100644 index 0000000..99d7cb8 --- /dev/null +++ b/src/cartridge/cnrom.rs @@ -0,0 +1,48 @@ +use super::{Cartridge, Mapper, Mirror}; + +pub struct Cnrom { + cart: Cartridge, + chr_bank_select: usize, +} + +impl Cnrom { + pub fn new(cart: Cartridge) -> Self { + Cnrom{ + cart: cart, + chr_bank_select: 0, + } + } +} + +impl Mapper for Cnrom { + fn read(&mut self, address: usize) -> u8 { + let cl = self.cart.chr_rom.len(); + let pl = self.cart.prg_rom.len(); + let addr = address % 0x4000; + match address { + 0x0000..=0x1FFF => self.cart.chr_rom[self.chr_bank_select][address], + 0x8000..=0xBFFF => self.cart.prg_rom[0][addr], + 0xC000..=0xFFFF => self.cart.prg_rom[pl-1][addr], + _ => panic!("bad address read from CNROM mapper: 0x{:X}", address), + } + } + + fn write(&mut self, address: usize, value: u8) { + match address { + 0x8000..=0xFFFF => self.chr_bank_select = (value & 0b11) as usize, + _ => println!("bad address written to CNROM mapper: 0x{:X}", address), + } + } + + fn get_mirroring(&mut self) -> Mirror { + self.cart.mirroring + // if self.cart.four_screen_vram { + // Mirror::FourScreen + // } else { + // self.cart.mirroring + // } + } + + fn load_battery_backed_ram(&mut self) {} + fn save_battery_backed_ram(&self) {} +} diff --git a/src/cartridge/mmc3.rs b/src/cartridge/mmc3.rs new file mode 100644 index 0000000..388dc8b --- /dev/null +++ b/src/cartridge/mmc3.rs @@ -0,0 +1,96 @@ +use super::{Cartridge, Mapper, Mirror}; + +pub struct Mmc3 { + cart: Cartridge, + + reg0: u8, + reg1: u8, + reg2: u8, + reg3: u8, + reg4: u8, + reg5: u8, + reg6: u8, + reg7: u8, + + irq_counter: u8, + irq_latch: u8, +} + +impl Mmc3 { + pub fn new(cart: Cartridge) -> Self { + Mmc3{ + cart: cart, + + reg0: 0, + reg1: 0, + reg2: 0, + reg3: 0, + reg4: 0, + reg5: 0, + reg6: 0, + reg7: 0, + } + } +} + +impl Mmc3 { + +} + +impl Mapper for Mmc3 { + fn read(&mut self, address: usize) -> u8 { + match address { + 0x0000..=0x07FF => , + 0x0800..=0x0FFF => , + 0x1000..=0x13FF => , + 0x1400..=0x17FF => , + 0x1800..=0x1BFF => , + 0x1C00..=0x1FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + } + } + + fn write(&mut self, address: usize, value: u8) { + match address % 2 == 0 { + true => { // even + match address { + 0x8000..=0x9FFF => self.bank_select(address), + 0xA000..=0xBFFF => self.mirroring = if value & 1 == 0 {Mirror::Vertical} else {Mirror::Horizontal}, + 0xC000..=0xDFFF => , + 0x1400..=0x17FF => , + 0x1800..=0x1BFF => , + 0x1C00..=0x1FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + } + }, + false => { // odd + match address { + 0x8000..=0x9FFF => self.bank_data(value), + 0xA000..=0xBFFF => self.prg_ram_protect(value), + 0xC000..=0xDFFF => , + 0x1400..=0x17FF => , + 0x1800..=0x1BFF => , + 0x1C00..=0x1FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + 0x6000..=0x7FFF => , + } + }, + } + + fn get_mirroring(&mut self) -> Mirror {} + + fn load_battery_backed_ram(&mut self) {} + + fn save_battery_backed_ram(&self) {} +} diff --git a/src/cartridge/mod.rs b/src/cartridge/mod.rs index 571ad01..d8ad17f 100644 --- a/src/cartridge/mod.rs +++ b/src/cartridge/mod.rs @@ -1,8 +1,14 @@ mod nrom; mod mmc1; +mod uxrom; +mod cnrom; +// mod mmc3; use nrom::Nrom; use mmc1::Mmc1; +use uxrom::Uxrom; +use cnrom::Cnrom; +// use mmc3::Mmc3; use std::cell::RefCell; use std::rc::Rc; @@ -22,6 +28,7 @@ pub enum Mirror { HighBank, Horizontal, Vertical, + FourScreen, } pub fn get_mapper() -> Rc> { @@ -30,6 +37,9 @@ pub fn get_mapper() -> Rc> { match num { 0 => Rc::new(RefCell::new(Nrom::new(cart))), 1 => Rc::new(RefCell::new(Mmc1::new(cart))), + 2 => Rc::new(RefCell::new(Uxrom::new(cart))), + 3 => Rc::new(RefCell::new(Cnrom::new(cart))), + // 4 => Rc::new(RefCell::new(Mmc3::new(cart))), _ => panic!("unimplemented mapper: {}", num), } } @@ -41,7 +51,7 @@ pub struct Cartridge { pub mirroring: Mirror, // 0 horizontal, 1 vertical battery_backed_ram: bool, // 1: Cartridge contains battery-backed PRG RAM ($6000-7FFF) or other persistent memory trainer_present: bool, // 1: 512-byte trainer at $7000-$71FF (stored before PRG data) - _four_screen_vram: u8, // 1: Ignore mirroring control or above mirroring bit; instead provide four-screen VRAM + four_screen_vram: bool, // 1: Ignore mirroring control or above mirroring bit; instead provide four-screen VRAM // TODO: other iNES header flags pub prg_rom: Vec>, // 16 KiB chunks for CPU @@ -68,7 +78,7 @@ impl Cartridge { mirroring: if data[6] & (1 << 0) == 0 {Mirror::Horizontal} else {Mirror::Vertical}, battery_backed_ram: data[6] & (1 << 1) != 0, trainer_present: data[6] & (1 << 2) != 0, - _four_screen_vram: (data[6] & (1 << 3) != 0) as u8, + four_screen_vram: data[6] & (1 << 3) != 0, prg_rom: Vec::new(), chr_rom: Vec::new(), all_data: data, diff --git a/src/cartridge/nrom.rs b/src/cartridge/nrom.rs index 183fc44..4cbc6c6 100644 --- a/src/cartridge/nrom.rs +++ b/src/cartridge/nrom.rs @@ -31,7 +31,7 @@ impl Mapper for Nrom { 0xC000..=0xFFFF => { self.cart.prg_rom[pl-1][addr] }, - _ => panic!("bad address sent to NROM mapper: 0x{:X}", address), + _ => {println!("bad address read from NROM mapper: 0x{:X}", address); 0}, } } @@ -45,13 +45,9 @@ impl Mapper for Nrom { self.cart.chr_rom[cl-1][address] = value; } }, - 0x8000..=0xBFFF => { - self.cart.prg_rom[0][addr] = value; - }, - 0xC000..=0xFFFF => { - self.cart.prg_rom[pl-1][addr] = value; - }, - _ => panic!("bad address sent to NROM mapper: 0x{:X}", address), + 0x8000..=0xBFFF => self.cart.prg_rom[0][addr] = value, + 0xC000..=0xFFFF => self.cart.prg_rom[pl-1][addr] = value, + _ => println!("bad address written to NROM mapper: 0x{:X}", address), } } diff --git a/src/cartridge/uxrom.rs b/src/cartridge/uxrom.rs new file mode 100644 index 0000000..dc62e15 --- /dev/null +++ b/src/cartridge/uxrom.rs @@ -0,0 +1,53 @@ +use super::{Cartridge, Mapper, Mirror}; + +pub struct Uxrom { + cart: Cartridge, + chr_ram: Vec, + bank_select: usize, +} + +impl Uxrom { + pub fn new(cart: Cartridge) -> Self { + Uxrom{ + cart: cart, + chr_ram: vec![0; 0x2000], + bank_select: 0, + } + } +} + +impl Mapper for Uxrom { + fn read(&mut self, address: usize) -> u8 { + match address { + 0x0000..=0x1FFF => { + if self.cart.chr_rom_size > 0 { + self.cart.chr_rom[0][address] + } else { + self.chr_ram[address] + } + }, + 0x8000..=0xBFFF => self.cart.prg_rom[self.bank_select][address % 0x4000], + 0xC000..=0xFFFF => self.cart.prg_rom[self.cart.prg_rom.len()-1][address % 0x4000], + _ => {println!("bad address read from UxROM mapper: 0x{:X}", address); 0}, + } + } + + fn write(&mut self, address: usize, value: u8) { + match address { + 0x0000..=0x1FFF => { + if self.cart.chr_rom_size == 0 { + self.chr_ram[address] = value; + } + }, + 0x8000..=0xFFFF => self.bank_select = value as usize, + _ => println!("bad address written to UxROM mapper: 0x{:X}", address), + } + } + + fn get_mirroring(&mut self) -> Mirror { + self.cart.mirroring + } + + fn load_battery_backed_ram(&mut self) {} + fn save_battery_backed_ram(&self) {} +} diff --git a/src/ppu/memory.rs b/src/ppu/memory.rs index f4cafd0..011f45b 100644 --- a/src/ppu/memory.rs +++ b/src/ppu/memory.rs @@ -55,19 +55,28 @@ impl super::Ppu { let base = address % 0x1000; let offset = base % 0x0400; match self.mapper.borrow_mut().get_mirroring() { - Mirror::LowBank => self.nametable_low_bank[offset], - Mirror::HighBank => self.nametable_high_bank[offset], + Mirror::LowBank => self.nametable_A[offset], + Mirror::HighBank => self.nametable_B[offset], Mirror::Horizontal => { match base { - 0x0000..=0x07FF => self.nametable_low_bank[offset], - 0x0800..=0x0FFF => self.nametable_high_bank[offset], + 0x0000..=0x07FF => self.nametable_A[offset], + 0x0800..=0x0FFF => self.nametable_B[offset], _ => panic!("panicked reading nametable base: {}", base), } }, Mirror::Vertical => { match base { - 0x0000..=0x03FF | 0x0800..=0x0BFF => self.nametable_low_bank[offset], - 0x0400..=0x07FF | 0x0C00..=0x0FFF => self.nametable_high_bank[offset], + 0x0000..=0x03FF | 0x0800..=0x0BFF => self.nametable_A[offset], + 0x0400..=0x07FF | 0x0C00..=0x0FFF => self.nametable_B[offset], + _ => panic!("panicked reading nametable base: {}", base), + } + }, + Mirror::FourScreen => { + match base { + 0x0000..=0x03FF => self.nametable_A[offset], + 0x0400..=0x07FF => self.nametable_B[offset], + 0x0800..=0x0BFF => self.nametable_C[offset], + 0x0C00..=0x0FFF => self.nametable_D[offset], _ => panic!("panicked reading nametable base: {}", base), } }, @@ -78,23 +87,28 @@ impl super::Ppu { let base = address % 0x1000; let offset = base % 0x0400; match self.mapper.borrow_mut().get_mirroring() { - Mirror::LowBank => { - self.nametable_low_bank[offset] = value; - }, - Mirror::HighBank => { - self.nametable_high_bank[offset] = value; - }, + Mirror::LowBank => self.nametable_A[offset] = value, + Mirror::HighBank => self.nametable_B[offset] = value, Mirror::Horizontal => { match base { - 0x0000..=0x07FF => self.nametable_low_bank[offset] = value, - 0x0800..=0x0FFF => self.nametable_high_bank[offset] = value, + 0x0000..=0x07FF => self.nametable_A[offset] = value, + 0x0800..=0x0FFF => self.nametable_B[offset] = value, _ => panic!("panicked writing nametable base: {}", base), } }, Mirror::Vertical => { match base { - 0x0000..=0x03FF | 0x0800..=0x0BFF => self.nametable_low_bank[offset] = value, - 0x0400..=0x07FF | 0x0C00..=0x0FFF => self.nametable_high_bank[offset] = value, + 0x0000..=0x03FF | 0x0800..=0x0BFF => self.nametable_A[offset] = value, + 0x0400..=0x07FF | 0x0C00..=0x0FFF => self.nametable_B[offset] = value, + _ => panic!("panicked writing nametable base: {}", base), + } + }, + Mirror::FourScreen => { + match base { + 0x0000..=0x03FF => self.nametable_A[offset] = value, + 0x0400..=0x07FF => self.nametable_B[offset] = value, + 0x0800..=0x0BFF => self.nametable_C[offset] = value, + 0x0C00..=0x0FFF => self.nametable_D[offset] = value, _ => panic!("panicked writing nametable base: {}", base), } }, diff --git a/src/ppu/mod.rs b/src/ppu/mod.rs index 8222fe1..3e92f1b 100644 --- a/src/ppu/mod.rs +++ b/src/ppu/mod.rs @@ -26,8 +26,10 @@ pub struct Ppu { // Pictures on http://wiki.nesdev.com/w/index.php/Mirroring refer to them as A and B. // http://wiki.nesdev.com/w/index.php/MMC1 calls them higher and lower. // They can be mirrored at certain memory ranges. - nametable_low_bank: Vec, - nametable_high_bank: Vec, + nametable_A: Vec, + nametable_B: Vec, + nametable_C: Vec, + nametable_D: Vec, // The palette shared by both background and sprites. // Consists of 32 bytes, each of which represents an index into the global PALETTE_TABLE. @@ -99,8 +101,10 @@ impl Ppu { x: 0, w: 0, mapper: mapper, - nametable_low_bank: vec![0u8; 0x0400], - nametable_high_bank: vec![0u8; 0x0400], + nametable_A: vec![0u8; 0x0400], + nametable_B: vec![0u8; 0x0400], + nametable_C: vec![0u8; 0x0400], + nametable_D: vec![0u8; 0x0400], palette_ram: vec![0u8; 0x0020], background_pattern_sr_low: 0, background_pattern_sr_high: 0,