mizu-core 1.3.0

The core library implementation of all Gameboy emulation for Mizu
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

use bitflags::bitflags;
use save_state::Savable;

use std::convert::From;

use crate::memory::{InterruptManager, InterruptType};

/// Joypad button types of the GameBoy.
pub enum JoypadButton {
    Start,
    Select,
    B,
    A,
    Down,
    Up,
    Left,
    Right,
}

bitflags! {
    #[derive(Default)]
    struct JoypadButtons:u8 {
        const START  = 1 << 7;
        const SELECT = 1 << 6;
        const B      = 1 << 5;
        const A      = 1 << 4;
        const DOWN   = 1 << 3;
        const UP     = 1 << 2;
        const LEFT   = 1 << 1;
        const RIGHT  = 1 << 0;
    }
}

impl From<JoypadButton> for JoypadButtons {
    fn from(button: JoypadButton) -> Self {
        match button {
            JoypadButton::Start => Self::START,
            JoypadButton::Select => Self::SELECT,
            JoypadButton::B => Self::B,
            JoypadButton::A => Self::A,
            JoypadButton::Down => Self::DOWN,
            JoypadButton::Up => Self::UP,
            JoypadButton::Left => Self::LEFT,
            JoypadButton::Right => Self::RIGHT,
        }
    }
}

#[derive(Savable)]
pub struct Joypad {
    #[savable(skip)]
    buttons: JoypadButtons,
    selecting_directions: bool,
    selecting_start: bool,

    old_p1: u8,
}

impl Default for Joypad {
    fn default() -> Self {
        Self {
            buttons: Default::default(),
            selecting_directions: true,
            selecting_start: true,
            old_p1: 0,
        }
    }
}

impl Joypad {
    /// returns the lower 4 bits of P1 (joypad register)
    pub fn get_keys_pressed(&self) -> u8 {
        let mut result = 0xF;

        if self.selecting_start {
            result &= !self.buttons.bits() >> 4;
        }
        if self.selecting_directions {
            result &= !self.buttons.bits();
        }

        result
    }

    pub fn read_joypad(&self) -> u8 {
        let result = self.get_keys_pressed();

        0xC0 | (((!self.selecting_start) as u8) << 5)
            | ((!self.selecting_directions as u8) << 4)
            | result
    }

    pub fn write_joypad(&mut self, data: u8) {
        self.selecting_start = ((data >> 5) & 1) == 0;
        self.selecting_directions = ((data >> 4) & 1) == 0;
    }

    pub fn update_interrupts<I: InterruptManager>(&mut self, interrupt: &mut I) {
        let new_p1 = self.get_keys_pressed();

        let should_interrupt = (self.old_p1 ^ new_p1) & self.old_p1 != 0;

        if should_interrupt {
            interrupt.request_interrupt(InterruptType::Joypad);
        }

        self.old_p1 = new_p1;
    }

    pub fn press_joypad(&mut self, button: JoypadButton) {
        self.buttons.insert(button.into())
    }

    pub fn release_joypad(&mut self, button: JoypadButton) {
        self.buttons.remove(button.into())
    }
}