tgbr 0.4.0

GameBoy emulator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

mod mbc1;
mod mbc2;
mod mbc3;
mod mbc5;

use ambassador::{delegatable_trait, Delegate};
use log::warn;
use serde::{Deserialize, Serialize};

use crate::{
    context,
    gameboy::Error,
    rom::{self, Rom},
    util::trait_alias,
};

trait_alias!(pub trait Context = context::Rom + context::ExternalRam);

#[allow(unused_variables)]
#[delegatable_trait]
pub trait MbcTrait {
    fn read(&mut self, ctx: &mut impl Context, addr: u16) -> u8;
    fn write(&mut self, ctx: &mut impl Context, addr: u16, data: u8) {}
    fn internal_ram(&self) -> Option<&[u8]> {
        None
    }
}

#[derive(Serialize, Deserialize)]
pub struct NullMbc {}

impl NullMbc {
    fn new(rom: &Rom) -> Self {
        assert_eq!(
            rom.rom_size,
            32 * 1024,
            "ROM only cartridge should be 32KiB"
        );
        Self {}
    }
}

impl MbcTrait for NullMbc {
    fn read(&mut self, ctx: &mut impl Context, addr: u16) -> u8 {
        match addr {
            0x0000..=0x3FFF => ctx.rom().data[addr as usize],
            0x4000..=0x7FFF => ctx.rom().data[addr as usize],
            0xA000..=0xBFFF => ctx.external_ram()[addr as usize - 0xA000],
            _ => panic!("{addr:04X}"),
        }
    }
    fn write(&mut self, ctx: &mut impl Context, addr: u16, data: u8) {
        match addr {
            0xA000..=0xBFFF => ctx.external_ram_mut()[addr as usize - 0xA000] = data,
            _ => warn!("Invalid address write: ${addr:04X} = ${data:02X}"),
        }
    }
}

macro_rules! def_mbc {
    ($($id:ident => $ty:ty,)*) => {
        #[derive(Serialize, Deserialize, Delegate)]
        #[delegate(MbcTrait)]
        pub enum Mbc {
            NullMbc(NullMbc),
            $(
                $id($ty),
            )*
        }

        pub fn create_mbc(rom: &Rom, internal_ram: Option<Vec<u8>>) -> Result<Mbc, Error> {
            let cart_type = rom.cartridge_type.clone();
            Ok(match cart_type.mbc {
                None => Mbc::NullMbc(NullMbc::new(rom)),
                $(
                    Some(rom::Mbc::$id) => Mbc::$id(<$ty>::new(rom, internal_ram)),
                )*
                Some(mbc) => Err(Error::UnsupportedMbc(mbc))?,
            })
        }
    }
}

def_mbc! {
    Mbc1 => mbc1::Mbc1,
    Mbc2 => mbc2::Mbc2,
    Mbc3 => mbc3::Mbc3,
    Mbc5 => mbc5::Mbc5,
}