neser 0.1.1

NESER - NES Emulator in Rust - is a NES emulator written in Rust. It aims to be a high-quality, hardware-accurate emulator that is also easy to use and extend. It supports a wide range of NES games and features, including various mappers, audio processing, and input handling. NESER is designed to be modular and extensible, allowing developers to easily add new features or support for additional hardware. It can be run using one of two frontends: a native desktop application using SDL2, or a web application using WebAssembly. The desktop application provides a high-performance, feature-rich experience with support for various input devices and display options, while the web application allows users to play NES games directly in their browsers without needing to install any software in a BYOR manner (Bring Your Own Roms).
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
134
135
136

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LatchTriggerMode {
    Mmc2,
    Mmc4,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Mmc2Mmc4Latch {
    pub bank_0_fd: u8,
    pub bank_0_fe: u8,
    pub bank_1_fd: u8,
    pub bank_1_fe: u8,
    pub latch0_is_fd: bool,
    pub latch1_is_fd: bool,
    mode: LatchTriggerMode,
}

impl Mmc2Mmc4Latch {
    pub fn new(mode: LatchTriggerMode) -> Self {
        Self {
            bank_0_fd: 0,
            bank_0_fe: 0,
            bank_1_fd: 0,
            bank_1_fe: 0,
            latch0_is_fd: false,
            latch1_is_fd: false,
            mode,
        }
    }

    pub fn selected_bank_0(&self) -> u8 {
        if self.latch0_is_fd {
            self.bank_0_fd
        } else {
            self.bank_0_fe
        }
    }

    pub fn selected_bank_1(&self) -> u8 {
        if self.latch1_is_fd {
            self.bank_1_fd
        } else {
            self.bank_1_fe
        }
    }

    pub fn update_for_chr_read(&mut self, addr: u16) {
        match self.mode {
            LatchTriggerMode::Mmc2 => match addr {
                0x0FD8 => self.latch0_is_fd = true,
                0x0FE8 => self.latch0_is_fd = false,
                0x1FD8..=0x1FDF => self.latch1_is_fd = true,
                0x1FE8..=0x1FEF => self.latch1_is_fd = false,
                _ => {}
            },
            LatchTriggerMode::Mmc4 => match addr {
                0x0FD8..=0x0FDF => self.latch0_is_fd = true,
                0x0FE8..=0x0FEF => self.latch0_is_fd = false,
                0x1FD8..=0x1FDF => self.latch1_is_fd = true,
                0x1FE8..=0x1FEF => self.latch1_is_fd = false,
                _ => {}
            },
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn mmc2_latch0_switches_only_on_exact_fd8_and_fe8() {
        let mut latch = Mmc2Mmc4Latch::new(LatchTriggerMode::Mmc2);

        assert!(!latch.latch0_is_fd);

        latch.update_for_chr_read(0x0FDF);
        assert!(!latch.latch0_is_fd);

        latch.update_for_chr_read(0x0FD8);
        assert!(latch.latch0_is_fd);

        latch.update_for_chr_read(0x0FEF);
        assert!(latch.latch0_is_fd);

        latch.update_for_chr_read(0x0FE8);
        assert!(!latch.latch0_is_fd);
    }

    #[test]
    fn mmc4_latch0_switches_on_fd8_fdf_and_fe8_fef_ranges() {
        let mut latch = Mmc2Mmc4Latch::new(LatchTriggerMode::Mmc4);

        assert!(!latch.latch0_is_fd);

        latch.update_for_chr_read(0x0FDF);
        assert!(latch.latch0_is_fd);

        latch.update_for_chr_read(0x0FEF);
        assert!(!latch.latch0_is_fd);
    }

    #[test]
    fn both_modes_use_range_triggers_for_latch1() {
        let mut mmc2 = Mmc2Mmc4Latch::new(LatchTriggerMode::Mmc2);
        let mut mmc4 = Mmc2Mmc4Latch::new(LatchTriggerMode::Mmc4);

        mmc2.update_for_chr_read(0x1FDF);
        mmc4.update_for_chr_read(0x1FDF);
        assert!(mmc2.latch1_is_fd);
        assert!(mmc4.latch1_is_fd);

        mmc2.update_for_chr_read(0x1FEF);
        mmc4.update_for_chr_read(0x1FEF);
        assert!(!mmc2.latch1_is_fd);
        assert!(!mmc4.latch1_is_fd);
    }

    #[test]
    fn selected_banks_follow_latch_states() {
        let mut latch = Mmc2Mmc4Latch::new(LatchTriggerMode::Mmc4);
        latch.bank_0_fd = 1;
        latch.bank_0_fe = 2;
        latch.bank_1_fd = 3;
        latch.bank_1_fe = 4;

        assert_eq!(latch.selected_bank_0(), 2);
        assert_eq!(latch.selected_bank_1(), 4);

        latch.latch0_is_fd = true;
        latch.latch1_is_fd = true;

        assert_eq!(latch.selected_bank_0(), 1);
        assert_eq!(latch.selected_bank_1(), 3);
    }
}