tinychip 0.1.1

CHIP-8 emulator/interpreter
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

use crate::apis::api::{
    RECTS_X,
    RECTS_Y
};

/// Manage the display memory as a matrice
#[derive(Clone)]
pub struct Vram {
    /// Array
    value: Vec::<u8>,
    /// Width
    w: usize,
    /// Height
    h: usize
}

impl Default for Vram {
    fn default() -> Self {
        Self::new(
            RECTS_X as usize,
            RECTS_Y as usize,
            0
        )
    }
}

impl Vram {
    pub fn new(w: usize, h: usize, byte: u8) -> Self {
        Self {
            value: vec![byte; w * h],
            w,
            h
        }
    }

    /// Clear the screen
    pub fn clear(&mut self) {
        for i in 0..(self.w * self.h) {
            self.value[i] = 0;
        }
    }

    /// Get the value
    pub fn value(&self) -> Vec::<u8> {
        self.value.clone()
    }

    /// Get the width
    pub fn w(&self) -> usize {
        self.w
    }

    /// Get the height
    pub fn h(&self) -> usize {
        self.h
    }

    /// Get the index
    pub fn index<T: Into<usize>>(&self, x: T, y: T) -> usize {
        (y.into() * self.w) + x.into()
    }

    /// Set a byte at the location (x, y)
    pub fn put<T: Into<usize>>(&mut self, x: T, y: T, byte: u8) {
        let index = self.index(x, y);

        self.value[index] = byte;
    }

    /// Return the byte at the location (x, y)
    pub fn get<T: Into<usize>>(&mut self, x: T, y: T) -> u8 {
        self.value[self.index(x, y)]
    }
}