gb-emu/src/processor/memory.rs

use self::rom::Rom;
use crate::{
    processor::{clear_bit, get_bit, SplitRegister},
    verbose_println,
};
use gilrs::{Button, ConnectedGamepadsIterator};
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<u8>,
    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,
    pub(super) apu_enabled: bool,
}

impl Memory {
    pub fn init(bootrom: Vec<u8>, 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(),
            apu_enabled: true,
        }
    }

    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 => 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 => {}
            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 {
                0xFF00 => {
                    // joypad
                    if !get_bit(data, 5) {
                        self.joypad.bank_sel = JoypadBank::Action
                    }
                    if !get_bit(data, 4) {
                        self.joypad.bank_sel = JoypadBank::Direction
                    }
                }
                0xFF02 => {
                    if data == 0x81 {
                        print!("{}", self.get(0xFF01) as char);
                        stdout().flush().unwrap();
                    }
                }
                0xFF04 => self.io[addr_l] = 0,
                0xFF07 => self.masked_io(addr_l, data, 0b111),
                0xFF0F => self.masked_io(addr_l, data, 0b11111),
                0xFF10 => self.masked_io(addr_l, data, 0b01111111),
                0xFF1A => self.masked_io(addr_l, data, 0b10000000),
                0xFF1C => self.masked_io(addr_l, data, 0b1100000),
                0xFF20 => self.masked_io(addr_l, data, 0b111111),
                0xFF23 => self.io[addr_l] = (self.io[addr_l] & 0b10111111) | (data & 0b01000000),
                0xFF26 => {
                    self.io[addr_l] = (self.io[addr_l] & 0b1111111) | (data & 0b10000000);
                    self.apu_enabled = self.io[addr_l] & 0b10000000 == 0b10000000
                }
                0xFF11 | 0xFF14 | 0xFF16 | 0xFF19 | 0xFF1E => {
                    // sound
                    self.io[addr_l] = data;
                }
                0xFF41 => {
                    // mixed read/write
                    self.masked_io(addr_l, data, 0b01111000);
                }
                0xFF4D | 0xFF56 => {
                    // cgb only
                    self.io[addr_l] = data;
                }
                0xFF03
                | 0xFF08..0xFF0F
                | 0xFF15
                | 0xFF1F
                | 0xFF27
                | 0xFF28
                | 0xFF29
                | 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;
                }
            }
        }
    }

    fn masked_io(&mut self, addr_l: usize, data: u8, mask: u8) {
        self.io[addr_l] = (self.io[addr_l] & (!mask)) | (data & mask);
    }

    pub fn update_pressed_keys(
        &mut self,
        keys: Vec<Key>,
        gamepads: ConnectedGamepadsIterator,
    ) -> bool {
        let old = self.joypad;
        self.joypad = Joypad {
            bank_sel: self.joypad.bank_sel,
            down: false,
            up: false,
            left: false,
            right: false,
            start: false,
            select: false,
            b: false,
            a: false,
        };
        for (_, pad) in gamepads {
            self.joypad.down |= pad.is_pressed(Button::DPadDown);
            self.joypad.up |= pad.is_pressed(Button::DPadUp);
            self.joypad.left |= pad.is_pressed(Button::DPadLeft);
            self.joypad.right |= pad.is_pressed(Button::DPadRight);
            self.joypad.start |= pad.is_pressed(Button::Start);
            self.joypad.select |= pad.is_pressed(Button::Select);
            self.joypad.a |= pad.is_pressed(Button::East);
            self.joypad.b |= pad.is_pressed(Button::South);
        }
        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 });
        }
    }
}