@tmustier/pi-nes 0.2.14 → 0.2.16

package/extensions/nes/native/nes-core/vendor/nes_rust/src/mapper.rs

@@ -118,7 +118,11 @@ impl Mapper for MMC1Mapper {
 	fn map(&self, address: u32) -> u32 {
 		let bank: u32;
 		let mut offset = address & 0x3FFF;
-		let bank_num = self.prg_bank_register.load() as u32 & 0x1F;
+		let bank_mask = if self.program_bank_num > 16 { 0x1F } else { 0x0F };
+		let mut bank_num = self.prg_bank_register.load() as u32 & bank_mask;
+		if self.program_bank_num > 0 {
+			bank_num %= self.program_bank_num as u32;
+		}
 
 		match self.control_register.load_bits(2, 2) {
 			0 | 1 => {
@@ -167,23 +171,23 @@ impl Mapper for MMC1Mapper {
 			self.register_write_count = 0;
 			self.latch.clear();
 			if (address & 0x6000) == 0 {
-				self.control_register.store_bits(2, 2, 3);
-			}
-		} else {
-			self.latch.store(((value & 1) << 4) | (self.latch.load() >> 1));
-			self.register_write_count += 1;
-
-			if self.register_write_count >= 5 {
-				let val = self.latch.load();
-				match address & 0x6000 {
-					0x0000 => self.control_register.store(val),
-					0x2000 => self.chr_bank0_register.store(val),
-					0x4000 => self.chr_bank1_register.store(val),
-					_ /*0x6000*/ => self.prg_bank_register.store(val)
-				};
-				self.register_write_count = 0;
-				self.latch.clear();
+				self.control_register.store(0x0C);
 			}
+			return;
+		}
+		self.latch.store(((value & 1) << 4) | (self.latch.load() >> 1));
+		self.register_write_count += 1;
+
+		if self.register_write_count >= 5 {
+			let val = self.latch.load();
+			match address & 0x6000 {
+				0x0000 => self.control_register.store(val),
+				0x2000 => self.chr_bank0_register.store(val),
+				0x4000 => self.chr_bank1_register.store(val),
+				_ /*0x6000*/ => self.prg_bank_register.store(val)
+			};
+			self.register_write_count = 0;
+			self.latch.clear();
 		}
 	}
 

package/extensions/nes/native/nes-core/vendor/nes_rust/src/ppu.rs

@@ -438,22 +438,22 @@ impl Ppu {
 		// 0x0000 - 0x1FFF is mapped with cartridge's CHR-ROM if exists.
 		// Otherwise load from VRAM.
 
-		match address < 0x2000 && rom.has_chr_rom() {
-			true => rom.load(address as u32),
-			false => self.vram.load(self.convert_vram_address(address, rom) as u32)
+		if address < 0x2000 {
+			return rom.load_chr(address as u32);
 		}
+		self.vram.load(self.convert_vram_address(address, rom) as u32)
 	}
 
 	fn store(&mut self, mut address: u16, value: u8, rom: &mut Rom) {
 		address = address & 0x3FFF;  // just in case
 
-		// 0x0000 - 0x1FFF is mapped with cartridge's CHR-ROM if exists.
-		// Otherwise store to VRAM.
+		// 0x0000 - 0x1FFF is mapped with cartridge CHR (ROM or RAM).
 
-		match address < 0x2000 && rom.has_chr_rom() {
-			true => rom.store(address as u32, value),
-			false => self.vram.store(self.convert_vram_address(address, rom) as u32, value)
-		};
+		if address < 0x2000 {
+			rom.store_chr(address as u32, value);
+			return;
+		}
+		self.vram.store(self.convert_vram_address(address, rom) as u32, value);
 	}
 
 	fn convert_vram_address(&self, address: u16, rom: &Rom) -> u16 {

package/extensions/nes/native/nes-core/vendor/nes_rust/src/rom.rs

@@ -4,6 +4,7 @@ use mapper::{Mapper, MapperFactory};
 pub struct Rom {
 	header: RomHeader,
 	memory: Memory,
+	chr_ram: Option<Memory>,
 	mapper: Box<dyn Mapper>
 }
 
@@ -26,9 +27,14 @@ impl Rom {
 		} else {
 			Vec::new()
 		};
+		let chr_ram = match header.chr_ram_size_bytes() {
+			0 => None,
+			size => Some(Memory::new(vec![0; size])),
+		};
 		Rom {
 			header: header,
 			memory: Memory::new(rom_data),
+			chr_ram,
 			mapper: mapper
 		}
 	}
@@ -43,21 +49,63 @@ impl Rom {
 	 * In general writing control registers in Mapper via .store() switches bank.
 	 */
 	pub fn load(&self, address: u32) -> u8 {
-		let mut address_in_rom = 0 as u32;
 		if address < 0x2000 {
-			// load from character rom
-			address_in_rom += self.header.prg_rom_bank_num() as u32 * 0x4000;
-			address_in_rom += self.mapper.map_for_chr_rom(address);
-		} else {
-			address_in_rom += self.mapper.map(address);
+			return self.load_chr(address);
+		}
+		self.memory.load(self.mapper.map(address))
+	}
+
+	pub fn load_chr(&self, address: u32) -> u8 {
+		let mapped = self.map_chr_address(address);
+		if let Some(chr_ram) = &self.chr_ram {
+			return chr_ram.load(mapped);
+		}
+		let offset = self.prg_rom_size() + mapped;
+		self.memory.load(offset)
+	}
+
+	pub fn store_chr(&mut self, address: u32, value: u8) {
+		let size = match self.chr_ram.as_ref() {
+			Some(ram) => ram.capacity(),
+			None => return,
+		};
+		if size == 0 {
+			return;
+		}
+		let mapped = self.mapper.map_for_chr_rom(address) % size;
+		if let Some(chr_ram) = self.chr_ram.as_mut() {
+			chr_ram.store(mapped, value);
 		}
-		self.memory.load(address_in_rom)
 	}
 
 	pub fn load_without_mapping(&self, address: u32) -> u8 {
 		self.memory.load(address)
 	}
 
+	fn prg_rom_size(&self) -> u32 {
+		self.header.prg_rom_bank_num() as u32 * 0x4000
+	}
+
+	fn chr_rom_size(&self) -> u32 {
+		self.header.chr_rom_bank_num() as u32 * 0x2000
+	}
+
+	fn chr_ram_size(&self) -> u32 {
+		self.chr_ram.as_ref().map_or(0, |ram| ram.capacity())
+	}
+
+	fn map_chr_address(&self, address: u32) -> u32 {
+		let size = if self.chr_ram.is_some() {
+			self.chr_ram_size()
+		} else {
+			self.chr_rom_size()
+		};
+		if size == 0 {
+			return 0;
+		}
+		self.mapper.map_for_chr_rom(address) % size
+	}
+
 	/**
 	 * In general writing with ROM address space updates control registers in Mapper.
 	 */
@@ -141,6 +189,13 @@ impl RomHeader {
 		self.chr_rom_bank_num() > 0
 	}
 
+	fn chr_ram_size_bytes(&self) -> usize {
+		if self.has_chr_rom() {
+			return 0;
+		}
+		0x2000
+	}
+
 	fn control_byte1(&self) -> u8 {
 		self.load(6)
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmustier/pi-nes",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "NES emulator extension for pi",
   "keywords": [
     "pi-package",