tmerritt/trevors_chip8_toy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

apply of clippy.

Browse Source 
fixed missing imports and builds and tests as expected again
This commit is contained in:
Trevor Merritt
2024-10-30 09:48:59 -04:00
parent 4fb2d6af29
commit 011874bca6
20 changed files with 114 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files
gemma/src/chip8/computer.rs
-1
View File
@@ -2,7 +2,6 @@ use log::{debug};
use crate::chip8::delay_timer::DelayTimer;
use crate::chip8::keypad::Keypad;
use crate::chip8::quirk_modes::QuirkMode;
use crate::chip8::quirk_modes::QuirkMode::Chip8;
use crate::chip8::registers::Chip8Registers;
use crate::chip8::sound_timer::SoundTimer;
use crate::chip8::stack::Chip8Stack;
gemma/src/chip8/computer_manager.rs
+6 -10
View File
@@ -1,6 +1,5 @@
use std::sync::mpsc::{channel, Sender};
use std::thread;
use std::thread::{sleep, JoinHandle, Thread};
use std::thread::sleep;
use std::time::{Duration, Instant};
use crate::chip8::computer::Chip8Computer;
use crate::chip8::cpu_states::Chip8CpuStates;
@@ -69,14 +68,11 @@ impl Chip8ComputerManager {
// println!("STARTING TICK");
let mut did_tick: bool = false;
if self.one_step | self.core_should_run {
match self.computer.state {
WaitingForInstruction => {
self.core_last_cycle_start = Instant::now();
self.computer.step_system();
did_tick = true
// println!("SYSTEM STEP");
}
_ => {}
if let WaitingForInstruction = self.computer.state {
self.core_last_cycle_start = Instant::now();
self.computer.step_system();
did_tick = true
// println!("SYSTEM STEP");
}
};
if self.one_step {
gemma/src/chip8/delay_timer.rs
+7 -1
View File
@@ -3,6 +3,12 @@ pub struct DelayTimer {
counter: u8
}
impl Default for DelayTimer {
fn default() -> Self {
Self::new()
}
}
impl DelayTimer {
pub fn current(&self) -> u8 {
self.counter
@@ -19,7 +25,7 @@ impl DelayTimer {
}
pub fn set_timer(&mut self, new_value: u8) {
self.counter = new_value as u8
self.counter = new_value
}
pub fn tick(&mut self) {
gemma/src/chip8/instructions.rs
+42 -44
View File
@@ -1,10 +1,8 @@
use std::arch::x86_64::_mm_xor_pd;
use std::fmt::{Debug, Display, Formatter};
use std::ops::{BitAnd, Deref, Shr};
use std::ops::BitAnd;
use std::time::Instant;
use chrono::ParseMonthError;
use log::debug;
use rand::{random, Rng};
use rand::Rng;
use crate::chip8::computer::{Chip8Computer};
use crate::chip8::cpu_states::Chip8CpuStates::WaitingForKey;
use crate::chip8::instructions::Chip8CpuInstructions::*;
@@ -548,11 +546,11 @@ impl Chip8CpuInstructions {
pub fn encode(&self) -> u16 {
match self {
Chip8CpuInstructions::SYS(target) => 0x0000 | (target & 0x0FFF) as u16,
Chip8CpuInstructions::SYS(target) => target & 0x0FFF,
Chip8CpuInstructions::CLS => 0x00E0,
Chip8CpuInstructions::RET => 0x00EE,
Chip8CpuInstructions::JPA(new_addr) => 0x1000 | (new_addr & 0x0FFF) as u16,
Chip8CpuInstructions::CALL(address) => 0x2000 | (address & 0x0FFF) as u16,
Chip8CpuInstructions::JPA(new_addr) => 0x1000 | (new_addr & 0x0FFF),
Chip8CpuInstructions::CALL(address) => 0x2000 | (address & 0x0FFF),
Chip8CpuInstructions::SEX(vx_register, byte) => 0x3000 | ((*vx_register as u16) << 8) | (*byte as u16),
Chip8CpuInstructions::SNEB(vx_register, byte) => 0x4000 | ((*vx_register as u16) << 8) | (*byte as u16),
Chip8CpuInstructions::SEY(x_register, y_register) => 0x5000 | ((*x_register as u16) << 8) | ((*y_register as u16) << 4),
@@ -695,10 +693,10 @@ impl Chip8CpuInstructions {
let start_time = Instant::now();
let start_pc = input.registers.peek_pc();
input.registers.poke_pc(start_pc + 2);
let _ = match self {
match self {
// 0x0nnn Exit to System Call
Chip8CpuInstructions::SYS(new_address) => {
input.registers.poke_pc(*new_address as u16);
input.registers.poke_pc(*new_address);
}
// * 0x00E0 Clear Screen
Chip8CpuInstructions::CLS => {
@@ -710,17 +708,17 @@ impl Chip8CpuInstructions {
}
// 0x1nnn Jump to Address
Chip8CpuInstructions::JPA(new_address) => {
input.registers.poke_pc(*new_address as u16);
input.registers.poke_pc(*new_address);
}
// 0x2nnn Call Subroutine
Chip8CpuInstructions::CALL(new_address) => {
let return_address = input.registers.peek_pc();
input.registers.poke_pc(*new_address as u16);
input.registers.poke_pc(*new_address);
input.stack.push(&return_address);
}
// 0x3xkk Skip next instruction if Vx = kk.
Chip8CpuInstructions::SEX(vx_register, byte) => {
if input.registers.peek(*vx_register as u8) == *byte as u8 {
if input.registers.peek(*vx_register) == { *byte } {
input.registers.advance_pc();
}
}
@@ -737,7 +735,7 @@ impl Chip8CpuInstructions {
}
// 0x5xy0 Skip next instruction if Vx == Vy
Chip8CpuInstructions::SEY(x, y) => {
if input.registers.peek(*x as u8) == input.registers.peek(*y as u8) {
if input.registers.peek(*x) == input.registers.peek(*y) {
input.registers.advance_pc();
}
}
@@ -751,37 +749,37 @@ impl Chip8CpuInstructions {
}
// 0x8xy0 Set value of Vy in Vx
Chip8CpuInstructions::LDR_Y(x, y) => {
input.registers.poke(*x as u8, input.registers.peek(*y as u8));
input.registers.poke(*x, input.registers.peek(*y));
}
// 0x8xy1 Set Vx = Vx OR Vy
Chip8CpuInstructions::OR(x, y) => {
// shift them to 16 bit
let working_16_x = input.registers.peek(*x as u8) as u16;
let working_16_y = input.registers.peek(*y as u8) as u16;
let working_16_x = input.registers.peek(*x) as u16;
let working_16_y = input.registers.peek(*y) as u16;
// OR them
let working_16_or = working_16_x | working_16_y;
// shift them back to 8 bit.
input.registers.poke(*x as u8, working_16_or as u8);
input.registers.poke(*x, working_16_or as u8);
debug!("OrVxVy [0x{x:1x}] [0x{y:1x}]")
}
// 0x8xy2 Set Vx = Vx AND Vy
Chip8CpuInstructions::AND(x, y) => {
let lhs_16 = input.registers.peek(*x as u8) as u16;
let rhs_16 = input.registers.peek(*y as u8) as u16;
input.registers.poke(*x as u8, (lhs_16 & rhs_16) as u8);
let lhs_16 = input.registers.peek(*x) as u16;
let rhs_16 = input.registers.peek(*y) as u16;
input.registers.poke(*x, (lhs_16 & rhs_16) as u8);
}
// 0x8xy3 Set Vx = Vx XOR Vy
Chip8CpuInstructions::ORY(x, y) => {
let lhs_16 = input.registers.peek(*x as u8) as u16;
let rhs_16 = input.registers.peek(*y as u8) as u16;
input.registers.poke(*x as u8, (lhs_16 ^ rhs_16) as u8);
let lhs_16 = input.registers.peek(*x) as u16;
let rhs_16 = input.registers.peek(*y) as u16;
input.registers.poke(*x, (lhs_16 ^ rhs_16) as u8);
}
// 0x8xy4 Set Vx = Vx + Vy (SET VF on Carry)
Chip8CpuInstructions::ADDR(x, y) => {
let lhs = input.registers.peek(*x as u8) as i16;
let rhs = input.registers.peek(*y as u8) as i16;
let lhs = input.registers.peek(*x) as i16;
let rhs = input.registers.peek(*y) as i16;
let working = lhs + rhs;
input.registers.poke(*x as u8, working as u8);
input.registers.poke(*x, working as u8);
if working >= 0x100 {
input.registers.poke(0xf, 0x01);
@@ -808,7 +806,7 @@ impl Chip8CpuInstructions {
1
};
input.registers.poke(*x as u8, result as u8);
input.registers.poke(*x, result as u8);
input.registers.poke(0x0f, borrow_flag);
}
Chip8CpuInstructions::SHR(x, _) => {
@@ -820,7 +818,7 @@ impl Chip8CpuInstructions {
// overflow check
let rotated = initial_value >> 1;
input.registers.poke(*x as u8, rotated);
input.registers.poke(*x, rotated);
if initial_value.bitand(0b1) == 1 {
input.registers.poke(0x0f, 0x01);
} else {
@@ -832,8 +830,8 @@ impl Chip8CpuInstructions {
// Set Vx = Vy - Vx, set VF = NOT borrow.
//
// If Vy > Vx, then VF is set to 1, otherwise 0. Then Vx is subtracted from Vy, and the results stored in Vx.
let y_register = input.registers.peek(*y as u8);
let x_register = input.registers.peek(*x as u8);
let y_register = input.registers.peek(*y);
let x_register = input.registers.peek(*x);
let mut value_to_poke = 0;
let new_value = if y_register < x_register {
@@ -859,7 +857,7 @@ impl Chip8CpuInstructions {
// overflow check
let rotated = initial_value << 1;
input.registers.poke(*x as u8, rotated);
input.registers.poke(*x, rotated);
if initial_value.bitand(0b10000000) == 0b10000000 {
input.registers.poke(0x0f, 0x01);
} else {
@@ -872,8 +870,8 @@ impl Chip8CpuInstructions {
//
// The values of Vx and Vy are compared, and if they are not equal, the program counter is increased by 2.
let x_reg_value = input.registers.peek(*vx_register as u8);
let y_reg_value = input.registers.peek(*vy_register as u8);
let x_reg_value = input.registers.peek(*vx_register);
let y_reg_value = input.registers.peek(*vy_register);
if x_reg_value != y_reg_value {
input.registers.advance_pc();
}
@@ -912,7 +910,7 @@ impl Chip8CpuInstructions {
let and_value: u8 = *byte;
let result = new_value & and_value;
debug!("RANDOM: [{new_value:02x}] AND: [{and_value:02x} Result: [{result:02x}]");
input.registers.poke(*x as u8, new_value & *byte as u8)
input.registers.poke(*x, new_value & { *byte })
}
Chip8CpuInstructions::DRW(y, x, n) => {
// Display n-byte sprite starting at memory location I at (Vx, Vy), set VF = collision.
@@ -968,7 +966,7 @@ impl Chip8CpuInstructions {
// Skip next instruction if key with the value of Vx is pressed.
//
// Checks the keyboard, and if the key corresponding to the value of Vx is currently in the down position, PC is increased by 2.
let key_to_check = input.registers.peek(*x as u8);
let key_to_check = input.registers.peek(*x);
let is_pressed = input.keypad.pressed(key_to_check);
if is_pressed {
input.registers.advance_pc();
@@ -982,7 +980,7 @@ impl Chip8CpuInstructions {
// Checks the keyboard,
// and if the key corresponding to the value of Vx is currently in the up position,
// PC is increased by 2.
let target_key = input.registers.peek(*x as u8);
let target_key = input.registers.peek(*x);
let is_pressed = input.keypad.pressed(target_key);
debug!("SnKpVx [{x:1x}]");
if !is_pressed {
@@ -995,7 +993,7 @@ impl Chip8CpuInstructions {
//
// The value of DT is placed into Vx.
let value_to_set = input.delay_timer.current();
input.registers.poke(*x as u8, value_to_set as u8);
input.registers.poke(*x, value_to_set);
}
Chip8CpuInstructions::LDRK(x) => {
// Fx0A - LD Vx, K
@@ -1009,11 +1007,11 @@ impl Chip8CpuInstructions {
// Set delay timer = Vx.
//
// DT is set equal to the value of Vx.
let new_time = input.registers.peek(*source_register as u8);
let new_time = input.registers.peek(*source_register);
input.delay_timer.set_timer(new_time);
}
Chip8CpuInstructions::LDIS(new_time) => {
let new_value = input.registers.peek(*new_time as u8);
let new_value = input.registers.peek(*new_time);
input.sound_timer.set_timer(new_value as i32);
}
Chip8CpuInstructions::ADDI(x) => {
@@ -1022,7 +1020,7 @@ impl Chip8CpuInstructions {
//
// The values of I and Vx are added, and the results are stored in I.
let base = input.registers.peek_i();
let x_value = input.registers.peek(*x as u8);
let x_value = input.registers.peek(*x);
input.registers.poke_i(base + x_value as u16);
}
Chip8CpuInstructions::LDFX(x) => {
@@ -1036,7 +1034,7 @@ impl Chip8CpuInstructions {
let x_value: u8 = input.registers.peek(*x);
let real_offset = x_value as u16 * 5;
input.registers.poke_i(real_offset as u16);
input.registers.poke_i(real_offset);
}
Chip8CpuInstructions::BCD(x) => {
// Fx33 - LD B, Vx
@@ -1046,7 +1044,7 @@ impl Chip8CpuInstructions {
// digit in memory at location in I, the tens digit at location I+1,
// and the ones digit at location I+2.
let to_convert = input.registers.peek(*x as u8);
let to_convert = input.registers.peek(*x);
// how many hundreds
let hundreds = to_convert / 100;
@@ -1070,7 +1068,7 @@ impl Chip8CpuInstructions {
// starting at the address in I.
let offset = input.registers.peek_i();
for i in 0..=*x {
input.memory.poke(offset + i as u16, input.registers.peek(i as u8));
input.memory.poke(offset + i as u16, input.registers.peek(i));
}
input.registers.poke_i(offset + 1);
}
@@ -1084,7 +1082,7 @@ impl Chip8CpuInstructions {
debug!("WILL READ {num_loops:x} BYTES");
for index in 0..num_loops {
let src_value = input.memory.peek(index as u16 + offset);
input.registers.poke(index as u8, src_value);
input.registers.poke(index, src_value);
debug!("POKING Register 0x{index:02x} with 0x{src_value:04x} using offset 0x{offset:04x}");
}
input.registers.poke_i(offset + 1);
gemma/src/chip8/keypad.rs
+1 -7
View File
@@ -1,6 +1,7 @@
use crate::constants::CHIP8_KEYBOARD;
#[derive(Clone, Copy)]
#[derive(Default)]
pub struct Keypad {
keys: [bool; 0x10],
}
@@ -30,13 +31,6 @@ impl Keypad {
}
}
impl Default for Keypad {
fn default() -> Self {
Keypad {
keys: [ false; 16]
}
}
}
impl Keypad {
pub fn push_key(&mut self, key_index: u8) {
gemma/src/chip8/sound_timer.rs
+6
View File
@@ -5,6 +5,12 @@ pub struct SoundTimer {
counter: i32
}
impl Default for SoundTimer {
fn default() -> Self {
Self::new()
}
}
impl SoundTimer {
pub fn current(&self) -> i32 {
self.counter
gemma/src/chip8/stack.rs
+1 -7
View File
@@ -1,15 +1,9 @@
#[derive(Clone)]
#[derive(Default)]
pub struct Chip8Stack {
items: Vec<u16>
}
impl Default for Chip8Stack {
fn default() -> Self {
Chip8Stack {
items: vec![],
}
}
}
impl Chip8Stack {
pub fn push(&mut self, new_value: &u16) {
gemma/src/chip8/util.rs
+3 -3
View File
@@ -15,7 +15,7 @@ impl InstructionUtil {
for i in 0..to_convert.len() {
let new_bit = 0x1 << i;
if to_convert[i] {
return_value = return_value | new_bit
return_value |= new_bit
}
}
return_value
@@ -29,8 +29,8 @@ impl InstructionUtil {
}
pub fn join_bytes(high: u8, low: u8) -> u16 {
let result = (high as u16) << 8 | low as u16;
result
(high as u16) << 8 | low as u16
}
// nnn or addr - A 12-bit value, the lowest 12 bits of the instruction
gemma/src/chip8/video.rs
+4 -7
View File
@@ -1,5 +1,4 @@
use log::{debug};
use crate::chip8::util::InstructionUtil;
use crate::chip8::video::Chip8VideoModes::{HighRes, LowRes};
use crate::constants::{CHIP8_VIDEO_HEIGHT, CHIP8_VIDEO_MEMORY, CHIP8_VIDEO_WIDTH, SCHIP_VIDE_MEMORY, SCHIP_VIDEO_HEIGHT, SCHIP_VIDEO_WIDTH};
@@ -86,10 +85,8 @@ impl Chip8Video {
let old_value = self.memory[effective_address as usize];
let xored_value = new_value ^ old_value; // XOR of the video
// if the frame has already changed we dont care if it changed again.
if !self.has_frame_changed {
if old_value != xored_value {
self.has_frame_changed = true
};
if !self.has_frame_changed && old_value != xored_value {
self.has_frame_changed = true
}
// println!("VIDEO POKE COMPLETE WITH {effective_address} SET TO {xored_value}");
@@ -164,7 +161,7 @@ impl Chip8Video {
for current_row in 0..height {
let row_offset = current_row * width;
for current_column in (0..width - 4) {
for current_column in 0..width - 4 {
let source: usize = (row_offset + current_column) as usize;
let target: usize = source + 4;
self.memory[target] = self.memory[source];
@@ -184,7 +181,7 @@ impl Chip8Video {
let max_source_row = height - how_far;
for current_source_row in (0..max_source_row).rev() {
let current_source_offset = current_source_row * width;
for current_source_column in (0..width) {
for current_source_column in 0..width {
let base_offset: usize = (current_source_offset + current_source_column) as usize;
let extended_offset: usize = base_offset + row_shift as usize;
self.memory[extended_offset] = self.memory[base_offset];
gemma/tests/computer_tests.rs
+5 -5
View File
@@ -34,7 +34,7 @@ fn reset_clears_video() {
fn level1_test() {
let mut x = Chip8Computer::new();
let level_1_rom = load_rom("1-chip8-logo.ch8");
x.load_bytes_to_memory(0x200, (&level_1_rom).into());
x.load_bytes_to_memory(0x200, (&level_1_rom));
// run for 0x40 cycles
while x.num_cycles < 0x40 {
@@ -49,7 +49,7 @@ fn level2_test() {
// Load the IBM rom and run it.
// it takes 39 cycles to get to the end so lets run it 40.
let test_rom_to_run = load_rom("2-ibm-logo.ch8");
x.load_bytes_to_memory(0x200, (&test_rom_to_run).into());
x.load_bytes_to_memory(0x200, (&test_rom_to_run));
for _ in 0..40 {
x.step_system();
}
@@ -64,7 +64,7 @@ fn level3_test() {
let mut x = Chip8Computer::new();
x.load_bytes_to_memory(
0x200, (&load_rom("3-corax+.ch8")).into()
0x200, (&load_rom("3-corax+.ch8"))
);
for i in 0..0x180 {
x.step_system();
@@ -76,7 +76,7 @@ fn level3_test() {
#[test]
fn rps_test() {
let mut x = Chip8Computer::new();
x.load_bytes_to_memory(0x200, &load_rom("RPS.ch8").into());
x.load_bytes_to_memory(0x200, &load_rom("RPS.ch8"));
for _ in 0..0xF0 {
x.step_system();
}
@@ -92,7 +92,7 @@ fn rps_test() {
fn level4_test() {
// flags
let mut x = Chip8Computer::new();
x.load_bytes_to_memory(0x200, &load_rom("4-flags.ch8").into());
x.load_bytes_to_memory(0x200, &load_rom("4-flags.ch8"));
for _ in 0..0x400 {
x.step_system();
}
gemma/tests/unit_tests.rs
+14 -16
View File
@@ -1,12 +1,10 @@
use std::collections::{BTreeMap, BTreeSet};
use log::debug;
use rand::random;
use gemma::chip8::computer::Chip8Computer;
use gemma::chip8::delay_timer::DelayTimer;
use gemma::chip8::instructions::Chip8CpuInstructions;
use gemma::chip8::instructions::Chip8CpuInstructions::JPA;
use gemma::chip8::keypad::Keypad;
use gemma::chip8::quirk_modes::QuirkMode::{Chip8, SChipModern, XOChip};
use gemma::chip8::quirk_modes::QuirkMode::Chip8;
use gemma::chip8::registers::Chip8Registers;
use gemma::chip8::sound_timer::SoundTimer;
use gemma::chip8::stack::Chip8Stack;
@@ -300,7 +298,7 @@ fn cls_test() {
Chip8CpuInstructions::CLS.execute(&mut x);
assert_eq!(x.registers.peek_pc(), 0x202);
for i in 0..CHIP8_VIDEO_MEMORY {
assert_eq!(x.video_memory.peek(i as u16), false);
assert!(!x.video_memory.peek(i as u16));
}
// draw some thing to the video memory
x.video_memory.poke(0x01, true);
@@ -310,7 +308,7 @@ fn cls_test() {
Chip8CpuInstructions::CLS.execute(&mut x);
for i in 0..CHIP8_VIDEO_MEMORY {
assert_eq!(x.video_memory.peek(i as u16), false);
assert!(!x.video_memory.peek(i as u16));
}
}
@@ -778,7 +776,7 @@ fn keypad_keys_check() {
#[test]
fn keypad_string_format_test() {
let mut k = Keypad::new();
let k = Keypad::new();
assert_eq!(k.format_as_string(), read_test_result("gemma_keypad_string_result.asc"));
@@ -998,7 +996,7 @@ fn video_default_test() {
for i in 0..CHIP8_VIDEO_MEMORY {
assert!(!x.clone().peek(i as u16));
// then flip the value and test again.
&x.poke(i as u16, true);
x.poke(i as u16, true);
assert!(x.clone().peek(i as u16));
}
}
@@ -1050,7 +1048,7 @@ fn video_poke_2byte_test() {
let mut expected = String::new();
expected = "** **** **** ".to_string() + &*" ".repeat(64 - 16).to_string() + "\n";
for i in 0..31 {
expected += &*((&*" ".repeat(64)).to_string() + "\n");
expected += &*((*" ".repeat(64)).to_string() + "\n");
}
assert_eq!(expected, x.format_as_string());
@@ -1065,7 +1063,7 @@ fn video_poke_multirow_2_byte_sprite() {
fn video_cls_stddef() {
let width = 64;
let height = 32;
let mut initial_memory = vec![];
let initial_memory = vec![];
let mut ws = String::new();
let mut set_x = Chip8Video::new(initial_memory.into());
for cbr in 0..32 {
@@ -1186,7 +1184,7 @@ fn video_verify_change_registered() {
#[test]
fn video_write_checkboard() {
let mut v = build_checkerboard();
let v = build_checkerboard();
assert_eq!(v.clone().format_as_string(), read_test_result("test_video_write_checkerboard.asc"));
}
@@ -1234,23 +1232,23 @@ fn video_collision_test() {
// set the cell thats already set...
x.poke(0x00, true);
// it becomes unset and theres a frame changed
assert_eq!(false, x.peek(0x00));
assert!(!x.peek(0x00));
assert_eq!(true, x.clone().has_frame_changed);
assert!(x.clone().has_frame_changed);
}
#[test]
fn video_collision_test2() {
let mut x = Chip8Video::default();
x.poke_byte(0x00, 0b11110000);
assert_eq!(true, x.has_frame_changed);
assert!(x.has_frame_changed);
x.tick();
assert_eq!(false, x.has_frame_changed);
assert!(!x.has_frame_changed);
// clear the 'has changed' flag
// now set a no-collision value
x.poke_byte(0x00, 0b00001111);
assert_eq!(true, x.has_frame_changed);
assert!(x.has_frame_changed);
}
#[test]
@@ -1280,7 +1278,7 @@ fn video_scroll_down_10_row_test() {
#[test]
fn video_high_res_has_right_resolution() {
let mut x = build_checkboard_hd();
let x = build_checkboard_hd();
println!("[{}]", x.format_as_string());
assert_eq!(read_test_result("test_video_highdef.asc"), x.format_as_string());
}