use std::fs;
|
|
use std::io::Read;
|
|
|
|
const w: usize = 64;
|
|
const h: usize = 32;
|
|
|
|
pub struct Chip8 {
|
|
opcode: u16,
|
|
memory: [u8; 4096],
|
|
v: [u8; 16],
|
|
index: u16,
|
|
pc: u16,
|
|
gfx: [u8; w * h],
|
|
delay_timer: u8,
|
|
sound_timer: u8,
|
|
stack: [u16; 16],
|
|
sp: isize,
|
|
key: [u8; 16],
|
|
pub draw_flag: bool,
|
|
}
|
|
|
|
const font_set: [u8; 80] = [
|
|
0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
|
|
0x20, 0x60, 0x20, 0x20, 0x70, // 1
|
|
0xF0, 0x10, 0xF0, 0x80, 0xF0, // 2
|
|
0xF0, 0x10, 0xF0, 0x10, 0xF0, // 3
|
|
0x90, 0x90, 0xF0, 0x10, 0x10, // 4
|
|
0xF0, 0x80, 0xF0, 0x10, 0xF0, // 5
|
|
0xF0, 0x80, 0xF0, 0x90, 0xF0, // 6
|
|
0xF0, 0x10, 0x20, 0x40, 0x40, // 7
|
|
0xF0, 0x90, 0xF0, 0x90, 0xF0, // 8
|
|
0xF0, 0x90, 0xF0, 0x10, 0xF0, // 9
|
|
0xF0, 0x90, 0xF0, 0x90, 0x90, // A
|
|
0xE0, 0x90, 0xE0, 0x90, 0xE0, // B
|
|
0xF0, 0x80, 0x80, 0x80, 0xF0, // C
|
|
0xE0, 0x90, 0x90, 0x90, 0xE0, // D
|
|
0xF0, 0x80, 0xF0, 0x80, 0xF0, // E
|
|
0xF0, 0x80, 0xF0, 0x80, 0x80, // F
|
|
];
|
|
|
|
impl Chip8 {
|
|
pub fn new() -> Chip8 {
|
|
let mut c = Chip8 {
|
|
opcode: 0,
|
|
memory: [0; 4096],
|
|
v: [0; 16],
|
|
index: 0,
|
|
pc: 0x200,
|
|
gfx: [0; w * h],
|
|
delay_timer: 0,
|
|
sound_timer: 0,
|
|
stack: [0; 16],
|
|
sp: 0,
|
|
key: [0; 16],
|
|
draw_flag: false,
|
|
};
|
|
|
|
for i in 0..font_set.len() {
|
|
c.memory[i] = font_set[i];
|
|
}
|
|
c
|
|
}
|
|
pub fn load_game(&mut self, filepath: &str) {
|
|
let mut f = fs::File::open(filepath).expect("can not load rom file");
|
|
let metadata = fs::metadata(filepath).expect("unable to read metadata");
|
|
let mut b = vec![0; metadata.len() as usize];
|
|
f.read(&mut b).expect("buffer overflow");
|
|
for i in 0..b.len() {
|
|
self.memory[512 + i] = b[i];
|
|
}
|
|
}
|
|
pub fn emulate_cycle(&mut self) {
|
|
self.opcode = (self.memory[self.pc as usize] as u16) << 8
|
|
| self.memory[(self.pc + 1) as usize] as u16;
|
|
let x: usize = ((self.opcode & 0x0F00) >> 8) as usize;
|
|
let y: usize = ((self.opcode & 0x00F0) >> 4) as usize;
|
|
let nn: u8 = (self.opcode & 0x00FF) as u8;
|
|
let nnn: u16 = (self.opcode & 0x0FFF) as u16;
|
|
// TODO
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn test_load_game() {
|
|
let mut c = Chip8::new();
|
|
c.load_game("Cargo.toml");
|
|
c.emulate_cycle();
|
|
// println!("{:?}", c.memory);
|
|
}
|
|
}
|