gametank 0.17.1

Hardware abstraction layer for the GameTank console
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

use bit_field::BitField;

const GPR1: *const u8 = 0x2008 as *const u8;
const GPR2: *const u8 = 0x2009 as *const u8;

#[inline(always)]
fn read_gpr1() -> u8 {
    unsafe { core::ptr::read_volatile(GPR1) }
}

#[inline(always)]
fn read_gpr2() -> u8 {
    unsafe { core::ptr::read_volatile(GPR2) }
}

#[derive(Debug, Copy, Clone)]
pub enum Buttons {
    Start,
    A,
    B,
    C,
    Up,
    Down,
    Left,
    Right
}

impl Buttons {
    /// good shit, const brained
    const fn idx(&self) -> usize {
        match self {
            Buttons::Start => 7,
            Buttons::A => 6,
            Buttons::B => 4,
            Buttons::C => 5,

            Buttons::Up => 3,
            Buttons::Down => 2,
            Buttons::Left => 1,
            Buttons::Right => 0,
        }
    }
}

/// Controller for a specific port.
///
/// The port is a const generic, so `read()` is monomorphized at compile time
/// with no runtime branching.
///
/// - `Controller<1>` for port 1
/// - `Controller<2>` for port 2
pub struct GenesisGamepad<const PORT: u8> {
    pub buttons: u8,
    pub buttons_last: u8,
}

impl<const PORT: u8> GenesisGamepad<PORT> {
    pub const fn new() -> Self {
        Self {
            buttons: 0,
            buttons_last: 0,
        }
    }
}

impl GenesisGamepad<1> {
    /// Read port 1 controller state.
    #[inline(always)]
    pub fn read(&mut self) {
        // Reset select by reading GPR2, then read GPR1 twice
        let _ = read_gpr2();
        let byte0 = read_gpr1();
        let byte1 = read_gpr1();

        self.buttons_last = self.buttons;
        // bits: start, a | c, b, up, down, left, right
        self.buttons = ((!byte0 << 2) & 0b1100_0000) | (!byte1 & 0b0011_1111);
    }
}

impl GenesisGamepad<2> {
    /// Read port 2 controller state.
    #[inline(always)]
    pub fn read(&mut self) {
        // Reset select by reading GPR1, then read GPR2 twice
        let _ = read_gpr1();
        let byte0 = read_gpr2();
        let byte1 = read_gpr2();

        self.buttons_last = self.buttons;
        // bits: start, a | c, b, up, down, left, right
        self.buttons = ((!byte0 << 2) & 0b1100_0000) | (!byte1 & 0b0011_1111);
    }
}

impl<const PORT: u8> GenesisGamepad<PORT> {
    #[inline]
    pub fn is_pressed(&self, button: Buttons) -> bool {
        self.buttons.get_bit(button.idx())
    }

    #[inline]
    pub fn was_pressed(&self, button: Buttons) -> bool {
        self.buttons_last.get_bit(button.idx())
    }

    /// Returns true only on the frame the button was first pressed (edge-trigger).
    #[inline]
    pub fn just_pressed(&self, button: Buttons) -> bool {
        self.is_pressed(button) && !self.was_pressed(button)
    }

    /// Returns true only on the frame the button was released (edge-trigger).
    #[inline]
    pub fn just_released(&self, button: Buttons) -> bool {
        !self.is_pressed(button) && self.was_pressed(button)
    }
}