nesfuzz/src/cartridge/mmc3.rs

use super::{Cartridge, Mapper, Mirror};

pub struct Mmc3 {
    cart: Cartridge,
    mirroring: Mirror,

    bank_registers: Vec<usize>,
    next_bank: u8,

    irq_latch: u8,
    irq_counter: u8,
    irq_enable: bool,
    trigger_irq: bool, // signal to send to CPU
    reload_counter: bool,

    prg_ram_bank: Vec<u8>, // CPU $6000-$7FFF
    // 0: $8000-$9FFF swappable, $C000-$DFFF fixed to second-last bank
    // 1: $C000-$DFFF swappable, $8000-$9FFF fixed to second-last bank
    prg_rom_bank_mode: bool,
    // 0: two 2 KB banks at $0000-$0FFF, four 1 KB banks at $1000-$1FFF
    // 1: two 2 KB banks at $1000-$1FFF, four 1 KB banks at $0000-$0FFF

    chr_rom_bank_mode: bool,
    chr_ram_bank: Vec<u8>, // used if cartridge doesn't have any CHR-ROM, 8KB, $0000-$1FFF
}

impl Mmc3 {
    pub fn new(cart: Cartridge) -> Self {
        let m = cart.mirroring;
        Mmc3{
            cart: cart,
            mirroring: m,
            bank_registers: vec![0, 0, 0, 0, 0, 0, 0, 0],
            next_bank: 0,
            irq_latch: 0,
            irq_counter: 0,
            irq_enable: false,
            trigger_irq: false,
            reload_counter: false,
            prg_ram_bank: vec![0; 0x2000],
            prg_rom_bank_mode: false,
            chr_rom_bank_mode: false,
            chr_ram_bank: vec![0; 0x2000],
        }
    }

    fn bank_select(&mut self, value: u8) {
        self.next_bank = value & 0b111;
        // ?? = value & (1<<5); // Nothing on the MMC3, see MMC6
        self.prg_rom_bank_mode = value & (1<<6) != 0;
        self.chr_rom_bank_mode = value & (1<<7) != 0;
    }

    fn bank_data(&mut self, value: u8) {
        // R6 and R7 will ignore the top two bits, as the MMC3 has only 6 PRG ROM address lines.
        // R0 and R1 ignore the bottom bit, as the value written still counts banks in 1KB units but odd numbered banks can't be selected.
        self.bank_registers[self.next_bank as usize] = match self.next_bank {
            0 | 1 => value & 0b1111_1110,
            6 | 7 => value & 0b0011_1111,
            _ => value,
        } as usize;
    }

    fn prg_ram_protect(&mut self) {}
}

impl Mapper for Mmc3 {
    fn read(&mut self, address: usize) -> u8 {
        let val = match address {
            0x0000..=0x1FFF => { // reading from CHR-ROM
                let offset_1k = address % 0x400;
                let offset_2k = address % 0x800;
                let bank_reg_num = match self.chr_rom_bank_mode {
                    true => {
                        match address {
                            0x0000..=0x03FF => 2,
                            0x0400..=0x07FF => 3,
                            0x0800..=0x0BFF => 4,
                            0x0C00..=0x0FFF => 5,
                            0x1000..=0x17FF => 0,
                            0x1800..=0x1FFF => 1,
                            _ => panic!("oh no"),
                        }
                    },
                    false => {
                        match address {
                            0x0000..=0x07FF => 0,
                            0x0800..=0x0FFF => 1,
                            0x1000..=0x13FF => 2,
                            0x1400..=0x17FF => 3,
                            0x1800..=0x1BFF => 4,
                            0x1C00..=0x1FFF => 5,
                            _ => panic!("oh no"),
                        }
                    },
                };
                let bank_num = self.bank_registers[bank_reg_num];
                let chunk_num = bank_num / 8;
                let chunk_eighth = (bank_num % 8) * 0x400;
                if bank_reg_num == 0 || bank_reg_num == 1 { // dealing with 2K banks of 8K chunks
                    self.cart.chr_rom[chunk_num][chunk_eighth + offset_2k]
                } else { // dealing with 1K banks of 8K chunks
                    self.cart.chr_rom[chunk_num][chunk_eighth + offset_1k]
                }
            },

            0x6000..=0x7FFF => self.prg_ram_bank[address % 0x2000], // PRG-RAM
            
            0x8000..=0xFFFF => { // reading from PRG ROM, dealing with 8K banks of 16K chunks
                let offset_8k = address % 0x2000;
                let num_banks = self.cart.prg_rom_size * 2;
                let bank_num = match self.prg_rom_bank_mode {
                    true => {
                        match address {
                            0x8000..=0x9FFF => num_banks - 2,
                            0xA000..=0xBFFF => self.bank_registers[7],
                            0xC000..=0xDFFF => self.bank_registers[6],
                            0xE000..=0xFFFF => num_banks - 1,
                            _ => panic!("oh no"),                            
                        }
                    },
                    false => {
                        match address {
                            0x8000..=0x9FFF => self.bank_registers[6],
                            0xA000..=0xBFFF => self.bank_registers[7],
                            0xC000..=0xDFFF => num_banks - 2,
                            0xE000..=0xFFFF => num_banks - 1,
                            _ => panic!("oh no"),
                        }
                    },
                };
                let chunk_num = bank_num / 2;
                let chunk_half = (bank_num % 2) * 0x2000;
                self.cart.prg_rom[chunk_num][chunk_half + offset_8k]
                
            },
            _ => {
                println!("bad address read from MMC3: 0x{:X}", address);
                0
            },
        };
        val
    }

    fn write(&mut self, address: usize, value: u8) {
        if (0..=0x1FFF).contains(&address) {
            if self.cart.chr_rom_size == 0 {
                self.chr_ram_bank[address] = value;
            }
            return
        }
        match address % 2 == 0 {
            true => { // even
                match address {
                    0x6000..=0x7FFF => self.prg_ram_bank[address % 0x2000] = value, // PRG-RAM
                    0x8000..=0x9FFF => self.bank_select(value),
                    0xA000..=0xBFFF => self.mirroring = if value & 1 == 0 {Mirror::Vertical} else {Mirror::Horizontal},
                    0xC000..=0xDFFF => self.irq_latch = value,
                    0xE000..=0xFFFF => self.irq_enable = false,
                    _ => println!("bad address written to MMC3: 0x{:X}", address),
                }
            },
            false => { // odd
                match address {
                    0x6000..=0x7FFF => self.prg_ram_bank[address % 0x2000] = value, // PRG-RAM
                    0x8000..=0x9FFF => self.bank_data(value),
                    0xA000..=0xBFFF => self.prg_ram_protect(),
                    0xC000..=0xDFFF => self.reload_counter = true, // Writing any value to this register reloads the MMC3 IRQ counter at the NEXT rising edge of the PPU address, presumably at PPU cycle 260 of the current scanline.
                    0xE000..=0xFFFF => self.irq_enable = true,
                    _ => println!("bad address written to MMC3: 0x{:X}", address),
                }
            },
        }
    }

    fn get_mirroring(&mut self) -> Mirror {
        if self.cart.four_screen_vram {
            Mirror::FourScreen
        } else {
            self.mirroring
        }
    }

    fn load_battery_backed_ram(&mut self) {}
    fn save_battery_backed_ram(&self) {}

    fn clock(&mut self) {
        if self.reload_counter {
            self.irq_counter = self.irq_latch;
            self.reload_counter = false;
        }
        // "Should reload and set IRQ every clock when reload is 0."
        if self.irq_latch == 0 && self.irq_enable {
            self.irq_counter = self.irq_latch;
            self.trigger_irq = true;
        }
        if self.irq_counter == 0 {
            self.irq_counter = self.irq_latch;
            return;
        } else {
            self.irq_counter -= 1;
        }
        if self.irq_counter == 0 && self.irq_enable {
            self.trigger_irq = true;
        }
    }

    fn check_irq(&mut self) -> bool {
        if self.trigger_irq {
            self.trigger_irq = false;
            true
        } else {
            false
        }
    }
}