use self::rom::ROM; use crate::{ processor::{clear_bit, get_bit, SplitRegister}, verbose_println, }; use minifb::Key; use std::io::{stdout, Write}; pub(crate) mod rom; pub(crate) type Address = u16; #[derive(Debug, Clone, Copy, PartialEq)] enum JoypadBank { Action, Direction, } #[derive(Debug, Clone, Copy, PartialEq)] struct Joypad { bank_sel: JoypadBank, down: bool, up: bool, left: bool, right: bool, start: bool, select: bool, b: bool, a: bool, } impl Joypad { fn as_register(&self) -> u8 { let mut reg = 0xFF; match self.bank_sel { JoypadBank::Action => { reg = clear_bit(reg, 5); if self.start { reg = clear_bit(reg, 3); } if self.select { reg = clear_bit(reg, 2); } if self.b { reg = clear_bit(reg, 1); } if self.a { reg = clear_bit(reg, 0); } } JoypadBank::Direction => { reg = clear_bit(reg, 4); if self.down { reg = clear_bit(reg, 3); } if self.up { reg = clear_bit(reg, 2); } if self.left { reg = clear_bit(reg, 1); } if self.right { reg = clear_bit(reg, 0); } } } reg } } impl Default for Joypad { fn default() -> Self { Self { bank_sel: JoypadBank::Action, down: false, up: false, left: false, right: false, start: false, select: false, b: false, a: false, } } } #[allow(dead_code)] pub struct Memory { bootrom: Vec, bootrom_enabled: bool, rom: ROM, vram: [u8; 8192], ram: [u8; 8192], switchable_ram: [u8; 8192], cpu_ram: [u8; 128], oam: [u8; 160], interrupts: u8, pub(super) ime: bool, pub(super) ime_scheduled: u8, io: [u8; 76], pub(super) user_mode: bool, joypad: Joypad, } impl Memory { pub fn init(bootrom: Vec, bootrom_enabled: bool, rom: ROM) -> Self { Self { bootrom, bootrom_enabled, rom, vram: [0x0; 8192], ram: [0x0; 8192], switchable_ram: [0x0; 8192], cpu_ram: [0x0; 128], oam: [0x0; 160], interrupts: 0x0, ime: false, ime_scheduled: 0x0, io: [0xFF; 76], user_mode: false, joypad: Joypad::default(), } } pub fn get(&self, address: Address) -> u8 { match address { 0x0..0x8000 => { // rom access // todo - switchable rom banks if self.bootrom_enabled && ((address as usize) < self.bootrom.len()) { self.bootrom[address as usize] } else { self.rom.get(address) } } 0x8000..0xA000 => { self.vram[(address - 0x8000) as usize] } 0xA000..0xC000 => { // cart ram self.rom.get_ram(address) } 0xC000..0xE000 => { self.ram[(address - 0xC000) as usize] } 0xE000..0xFE00 => { self.ram[(address - 0xE000) as usize] } 0xFE00..0xFEA0 => { self.oam[(address - 0xFE00) as usize] } 0xFEA0..0xFF00 => { 0xFF } 0xFF00..0xFF4C => self.get_io(address), 0xFF4C..0xFF80 => { // println!("empty space 2 read"); 0xFF } 0xFF80..0xFFFF => { self.cpu_ram[(address - 0xFF80) as usize] } 0xFFFF => { self.interrupts } } } pub fn set(&mut self, address: Address, data: u8) { match address { 0x0..0x8000 => { // change this with MBC code... self.rom.set(address, data); } 0x8000..0xA000 => { self.vram[(address - 0x8000) as usize] = data; } 0xA000..0xC000 => { self.rom.set_ram(address, data); } 0xC000..0xE000 => { self.ram[(address - 0xC000) as usize] = data; } 0xE000..0xFE00 => { self.ram[(address - 0xE000) as usize] = data; } 0xFE00..0xFEA0 => { self.oam[(address - 0xFE00) as usize] = data; } 0xFEA0..0xFF00 => { // println!("empty space write: {:#X} to addr {:#X}", data, address); } 0xFF00..0xFF4C => { self.set_io(address, data); stdout().flush().unwrap(); } 0xFF50 => { self.bootrom_enabled = false; } 0xFF4C..0xFF50 | 0xFF51..0xFF80 => {} 0xFF80..0xFFFF => { self.cpu_ram[(address - 0xFF80) as usize] = data; } 0xFFFF => { verbose_println!("interrupts set to {:#b}", data); verbose_println!(" / {:#X}", data); self.interrupts = data; } } } fn get_io(&self, address: Address) -> u8 { if address == 0xFF00 { return self.joypad.as_register(); } self.io[(address - 0xFF00) as usize] } fn set_io(&mut self, address: Address, data: u8) { let addr_l = (address - 0xFF00) as usize; if !self.user_mode { self.io[addr_l] = data; } else { match address { 0xFF02 => { if data == 0x81 { print!("{}", self.get(0xFF01) as char); stdout().flush().unwrap(); } } 0xFF04 => self.io[addr_l] = 0, 0xFF00 => { // joypad if !get_bit(data, 5) { self.joypad.bank_sel = JoypadBank::Action } if !get_bit(data, 4) { self.joypad.bank_sel = JoypadBank::Direction } } 0xFF11 | 0xFF14 | 0xFF16 | 0xFF19 | 0xFF1E | 0xFF23 | 0xFF26 => { // sound self.io[addr_l] = data; } 0xFF41 => { // mixed read/write self.io[addr_l] = (self.io[addr_l] & 0b00000111) | (data & 0b11111000) } 0xFF4D | 0xFF56 => { // cgb only self.io[addr_l] = data; } 0xFF44 | 0xFF76 | 0xFF77 => { // read-only addresses println!("BANNED write: {data:#X} to {address:#X}"); } 0xFF46 => { if data > 0xDF { panic!("dma transfer out of bounds: {data:#X}"); } self.io[addr_l] = data; let mut addr: u16 = 0x0; addr.set_high(data); for l in 0x0..0xA0 { addr.set_low(l); self.oam[l as usize] = self.get(addr); } } _ => { self.io[addr_l] = data; } } } } pub fn update_pressed_keys(&mut self, keys: Vec) -> bool { let old = self.joypad; self.joypad.down = keys.contains(&Key::Down) || keys.contains(&Key::S); self.joypad.up = keys.contains(&Key::Up) || keys.contains(&Key::W); self.joypad.left = keys.contains(&Key::Left) || keys.contains(&Key::A); self.joypad.right = keys.contains(&Key::Right) || keys.contains(&Key::D); self.joypad.start = keys.contains(&Key::Equal); self.joypad.select = keys.contains(&Key::Minus); self.joypad.a = keys.contains(&Key::Apostrophe); self.joypad.b = keys.contains(&Key::Semicolon); self.joypad != old } pub(super) fn cpu_ram_init(&mut self) { self.set(0xFF04, 0xAD); self.set(0xFF10, 0x80); self.set(0xFF11, 0xBF); self.set(0xFF12, 0xF3); self.set(0xFF14, 0xBF); self.set(0xFF16, 0x3F); self.set(0xFF19, 0xBF); self.set(0xFF1A, 0x7F); self.set(0xFF1B, 0xFF); self.set(0xFF1C, 0x9F); self.set(0xFF1E, 0xBF); self.set(0xFF20, 0xFF); self.set(0xFF23, 0xBF); self.set(0xFF24, 0x77); self.set(0xFF25, 0xF3); self.set(0xFF26, 0xF1); self.set(0xFF40, 0x91); self.set(0xFF47, 0xFC); self.set(0xFF48, 0xFF); self.set(0xFF49, 0xFF); for i in 0xC000..0xE000 { self.set(i, if rand::random() { 0xFF } else { 0x00 }); } } }