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

pub mod execute;
use thiserror::Error;

use self::execute::InstructionExecutionError;
use super::constants::INSTRUCTION_SIZE;
use super::{Blocked, Chip8};
use crate::chip8::Key;
use crate::memory::ReadInstructionError;

#[derive(Error, Debug)]
pub enum CycleError {
    #[error("instruction fetch error")]
    FetchError(#[from] ReadInstructionError),
    #[error("instruction execution error")]
    ExecutionError(#[from] InstructionExecutionError),
}

impl Chip8 {
    pub fn cycle(&mut self) -> Result<(), CycleError> {
        if self.blocked != Blocked::No {
            return Ok(());
        }

        let instruction = self.memory.read_instruction(self.program_counter)?;
        self.execute_instruction(instruction)?;

        // Auto-Increment only when not in jump
        if !self.in_jump {
            self.program_counter += INSTRUCTION_SIZE;
        }
        self.in_jump = false;

        Ok(())
    }

    pub fn handle_key_up_interrupt(&mut self, key: Key) {
        if let Blocked::WaitingOnKeyUp(vx) = self.blocked {
            self.data_registers[vx] = u8::from(key);
            self.blocked = Blocked::No;
        }
    }

    pub fn update_timers(&mut self) {
        if self.blocked != Blocked::No {
            return;
        }

        // Should be called at a rate of 60hz
        if self.delay_timer > 0 {
            self.delay_timer -= 1;
        }

        if self.sound_timer > 0 {
            self.sound_timer -= 1;
        }
    }
}