rust8 0.2.1

A Chip-8 Emulator Library in Rust
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

use self::constants::{DEFAULT_PROGRAM_ADDRESS, FONT_SPRITES, FONT_SPRITE_SIZE, STACK_SIZE};
use self::data_register::{DataRegister, DataRegisters};
use self::graphic::Screen;
use self::keyboard::{Key, Keyboard};
use self::memory::{Memory, WriteError};

pub mod constants;
pub mod cpu;
pub mod data_register;
pub mod graphic;
pub mod instruction;
pub mod keyboard;
pub mod memory;

#[derive(PartialEq)]
enum Blocked {
    No,
    WaitingOnKeyUp(DataRegister),
}

pub struct Chip8 {
    pub memory: Memory,

    pub data_registers: DataRegisters,
    pub address_register: usize,
    pub sound_timer: u8,
    pub delay_timer: u8,
    pub program_counter: usize,

    keyboard: Keyboard,
    pub stack: Vec<usize>,
    pub screen: Screen,
    in_jump: bool,
    blocked: Blocked,
}

impl Default for Chip8 {
    fn default() -> Self {
        Chip8 {
            data_registers: DataRegisters::new(),
            address_register: 0,
            keyboard: Keyboard::new(),
            in_jump: false,
            blocked: Blocked::No,
            delay_timer: 0,
            sound_timer: 0,
            stack: Vec::with_capacity(STACK_SIZE),
            program_counter: DEFAULT_PROGRAM_ADDRESS,
            memory: Memory::new(),
            screen: Screen::new(),
        }
    }
}

impl Chip8 {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn reset(&mut self) {
        self.data_registers.reset();
        self.address_register = 0;
        self.in_jump = false;
        self.delay_timer = 0;
        self.sound_timer = 0;
        self.stack.clear();
        self.program_counter = DEFAULT_PROGRAM_ADDRESS;
        self.memory.clear();
        self.screen.clear();
        self.blocked = Blocked::No;
    }

    pub fn key_up(&mut self, key: Key) {
        self.keyboard.key_up(key);
        self.handle_key_up_interrupt(key)
    }

    pub fn key_down(&mut self, key: Key) {
        self.keyboard.key_down(key);
    }

    fn load_font_sprites(&mut self) {
        for (i, sprite) in FONT_SPRITES.iter().enumerate() {
            self.memory
                .write_unrestricted(sprite, i * FONT_SPRITE_SIZE)
                .unwrap();
        }
    }

    pub fn load_program_to_address(
        &mut self,
        program: &[u8],
        address: usize,
    ) -> Result<(), WriteError> {
        self.reset();
        self.load_font_sprites();

        self.memory.write_restricted(program, address)?;
        self.program_counter = address;

        Ok(())
    }

    pub fn load_program(&mut self, program: &[u8]) -> Result<(), WriteError> {
        self.load_program_to_address(program, DEFAULT_PROGRAM_ADDRESS)
    }

    pub fn is_blocked(&self) -> bool {
        self.blocked != Blocked::No
    }
}