rbgb 0.2.0

A basic and rough 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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Contains all code for interfacing io to the gameboy

use debug_print::debug_println;

use crate::types::{GameInput, KeyState};

use super::mem::SharedMemory;

#[derive(Default)]
pub struct Joypad {
    // access to global shared memory
    mem: SharedMemory,

    // group 1 buttons
    a: KeyState,
    b: KeyState,
    start: KeyState,
    select: KeyState,

    // group 2 buttons
    right: KeyState,
    left: KeyState,
    up: KeyState,
    down: KeyState,
}

impl Joypad {
    pub fn new(mem: SharedMemory) -> Self {
        Joypad {
            mem,
            ..Default::default()
        }
    }

    /// Takes the input and affects the associated memory value with what it should be
    pub fn log_input(&mut self, input: GameInput, val: KeyState) {
        debug_println!("Registering input: {:?}", input);
        match input {
            // mode 0 buttons
            GameInput::A => self.a = val,
            GameInput::B => self.b = val,
            GameInput::Start => self.start = val,
            GameInput::Select => self.select = val,
            GameInput::Up => self.up = val,
            GameInput::Down => self.down = val,
            GameInput::Left => self.left = val,
            GameInput::Right => self.right = val,

            // unknown input
            _ => (),
        }

        self.write_input_to_mem();
    }

    /// Main hardworking function that does the work to write the joypad state to RAM
    fn write_input_to_mem(&mut self) {
        let mut buttons = 0;
        buttons |= self.a as u8;
        buttons |= (self.b as u8) << 1;
        buttons |= (self.select as u8) << 2;
        buttons |= (self.start as u8) << 3;

        let mut directions = 0;
        directions |= self.right as u8;
        directions |= (self.left as u8) << 1;
        directions |= (self.up as u8) << 2;
        directions |= (self.down as u8) << 3;

        let mut mem = self.mem.lock().unwrap();
        mem.update_joypad_state(buttons, directions);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::IF;
    use crate::{emulator::mem::Memory, types::INPUT_REGISTER};
    use std::sync::{Arc, Mutex};

    fn setup_joypad(select_bits: u8) -> (Joypad, SharedMemory) {
        let mem = Arc::new(Mutex::new(Memory::new()));
        mem.lock()
            .unwrap()
            .write_byte_forced(INPUT_REGISTER, 0xC0 | select_bits | 0x0F);
        (Joypad::new(Arc::clone(&mem)), mem)
    }

    #[test]
    fn buttons_selection_updates_lower_nibble_and_interrupts() {
        let (mut joypad, mem) = setup_joypad(0x10); // select buttons
        joypad.log_input(GameInput::A, KeyState::Pressed);

        let value = mem.lock().unwrap().read_byte_forced(INPUT_REGISTER);
        assert_eq!(value, 0xDE);

        let if_val = mem.lock().unwrap().read_byte_forced(IF);
        assert_eq!(if_val & (1 << 4), 1 << 4);
    }

    #[test]
    fn directions_selection_updates_lower_nibble() {
        let (mut joypad, mem) = setup_joypad(0x20); // select directions
        joypad.log_input(GameInput::Up, KeyState::Pressed);

        let value = mem.lock().unwrap().read_byte_forced(INPUT_REGISTER);
        assert_eq!(value, 0xEB);
    }

    #[test]
    fn no_selection_keeps_low_nibble_high_and_no_interrupt() {
        let (mut joypad, mem) = setup_joypad(0x30); // no selection
        joypad.log_input(GameInput::A, KeyState::Pressed);

        let value = mem.lock().unwrap().read_byte_forced(INPUT_REGISTER);
        assert_eq!(value, 0xFF);

        let if_val = mem.lock().unwrap().read_byte_forced(IF);
        assert_eq!(if_val & (1 << 4), 0);
    }

    #[test]
    fn release_does_not_request_interrupt() {
        let (mut joypad, mem) = setup_joypad(0x10); // select buttons
        joypad.log_input(GameInput::A, KeyState::Pressed);
        mem.lock().unwrap().write_byte_forced(IF, 0x00);

        joypad.log_input(GameInput::A, KeyState::Released);
        let if_val = mem.lock().unwrap().read_byte_forced(IF);
        assert_eq!(if_val & (1 << 4), 0);
    }
}