cleanup PR, add some tests

kirjavascript · kirjavascript · commit 9ffe6dda2c41 · 2024-05-06T21:21:05.000+01:00
diff --git a/src/nmi/render_mode_play_and_demo.asm b/src/nmi/render_mode_play_and_demo.asm
@@ -93,7 +93,7 @@ render_mode_play_and_demo:
         and #RENDER_SCORE
         beq @renderHz
 
-        ; 9 safe tile writes freed from stats / hz
+        ; 7 safe tile writes freed from stats / hz
         ; (lazy render hz for 10 more)
         ; 1 added in level (3 total)
         ; 2 added in lines (5 total)
diff --git a/tests/src/cycle_count.rs b/tests/src/cycle_count.rs
@@ -1,7 +1,56 @@
 use crate::{util, score, labels, playfield};
-use rusticnes_core::nes::NesState;
 
 pub fn count_cycles() {
+    test_hz_cycles();
+    test_max_score_cycles();
+    test_mode_score_cycles();
+}
+
+fn test_hz_cycles() {
+    // check max hz calculation amount
+    let mut emu = util::emulator(None);
+
+    let hz_flag = labels::get("hzFlag") as usize;
+    let game_mode = labels::get("gameMode") as usize;
+    let x = labels::get("tetriminoX") as usize;
+    let y = labels::get("tetriminoY") as usize;
+    let main_loop = labels::get("mainLoop");
+    let level_number = labels::get("levelNumber") as usize;
+    let debounce = labels::get("hzDebounceThreshold") as usize;
+
+    util::run_n_vblanks(&mut emu, 3);
+
+    emu.memory.iram_raw[hz_flag] = 1;
+    emu.memory.iram_raw[level_number] = 18;
+    emu.memory.iram_raw[game_mode] = 4;
+    emu.registers.pc = main_loop;
+
+    util::run_n_vblanks(&mut emu, 5);
+
+    let mut highest = 0;
+
+    for buttons in &[
+        "L.L.L.L.L",
+        "RR...R...R...R.R.",
+        ".....L.L..L.L.",
+        "LLL..L.L...L.R.R..L...R....L....L...L....L",
+        "R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R",
+    ] {
+        buttons.chars().for_each(|button| {
+            emu.memory.iram_raw[x] = 5;
+            emu.memory.iram_raw[y] = 0;
+            util::set_controller(&mut emu, button);
+            highest = highest.max(util::cycles_to_vblank(&mut emu));
+        });
+
+        util::run_n_vblanks(&mut emu, debounce + 1);
+    }
+
+    println!("hz display most cycles {}", highest);
+}
+
+fn test_max_score_cycles() {
+    // check max scoring cycle amount
     let mut emu = util::emulator(None);
 
     let completed_lines = labels::get("completedLines") as usize;
@@ -18,7 +67,6 @@ pub fn count_cycles() {
 
     let mut highest = 0;
 
-    // check every linecount on every level
     for level in 0..=255 {
         for lines in 0..=4 {
             let count = score(999999, lines, level);
@@ -30,9 +78,10 @@ pub fn count_cycles() {
     }
 
     println!("scoring routine most cycles: {}", highest);
+}
 
+fn test_mode_score_cycles() {
     // check clock cycles frames in each mode
-
     let mut emu = util::emulator(None);
 
     for mode in 0..labels::get("MODE_GAME_QUANTITY") {
@@ -76,7 +125,7 @@ pub fn count_cycles() {
             emu.memory.iram_raw[labels::get("autorepeatY") as usize] = 0;
 
             for _ in 0..45 {
-                let cycles = cycles_to_vblank(&mut emu);
+                let cycles = util::cycles_to_vblank(&mut emu);
 
                 if cycles > highest {
                     highest = cycles;
@@ -88,64 +137,4 @@ pub fn count_cycles() {
 
         println!("cycles {} lines {} mode {}", highest, lines, mode);
     }
-
-}
-
-fn cycles_to_vblank(emu: &mut NesState) -> u32 {
-    let vblank = labels::get("verticalBlankingInterval") as usize;
-    let mut cycles = 0;
-    let mut done = false;
-
-    while emu.ppu.current_scanline == 242 {
-        emu.cycle();
-        if !done {
-            cycles += 1;
-            if emu.memory.iram_raw[vblank] == 1 {
-                done = true;
-            }
-        }
-        let mut i = 0;
-        while emu.cpu.tick >= 1 && i < 10 {
-            emu.cycle();
-            if !done {
-                cycles += 1;
-                if emu.memory.iram_raw[vblank] == 1 {
-                    done = true;
-                }
-            }
-            i += 1;
-        }
-        if emu.ppu.current_frame != emu.last_frame {
-            emu.event_tracker.swap_buffers();
-            emu.last_frame = emu.ppu.current_frame;
-        }
-    }
-    emu.memory.iram_raw[vblank] = 1;
-    done = false;
-    while emu.ppu.current_scanline != 242 {
-        emu.cycle();
-        if !done {
-            cycles += 1;
-            if emu.memory.iram_raw[vblank] == 0 {
-                done = true;
-            }
-        }
-        let mut i = 0;
-        while emu.cpu.tick >= 1 && i < 10 {
-            emu.cycle();
-            if !done {
-                cycles += 1;
-                if emu.memory.iram_raw[vblank] == 0 {
-                    done = true;
-                }
-            }
-            i += 1;
-        }
-        if emu.ppu.current_frame != emu.last_frame {
-            emu.event_tracker.swap_buffers();
-            emu.last_frame = emu.ppu.current_frame;
-        }
-    }
-
-    cycles
 }
diff --git a/tests/src/hz_display.rs b/tests/src/hz_display.rs
@@ -1,4 +1,4 @@
-use crate::{input, labels, util};
+use crate::{labels, util};
 use rusticnes_core::nes::NesState;
 
 pub fn test() {
@@ -9,9 +9,7 @@ pub fn test() {
 fn test_standard() {
     let mut emu = util::emulator(None);
 
-    for _ in 0..4 {
-        emu.run_until_vblank();
-    }
+    util::run_n_vblanks(&mut emu, 4);
 
     let hz_flag = labels::get("hzFlag") as usize;
     let game_mode = labels::get("gameMode") as usize;
@@ -90,25 +88,12 @@ fn test_tspin() {
     assert_hz_display(&mut emu, HzSpeed(0, 0), 1, -3, Dir::Right);
 }
 
-// note:
 fn run_input_string(emu: &mut NesState, inputs: &str) {
     for button in inputs.chars() {
-        let controller_data = match button {
-            'L' => input::LEFT,
-            'R' => input::RIGHT,
-            'D' => input::DOWN,
-            'U' => input::UP,
-            'A' => input::A,
-            'B' => input::B,
-            'S' => input::START,
-            'T' => input::SELECT,
-            '.' => 0,
-            _ => panic!("character '{}' cannot be used as controller input", button),
-        };
-        util::set_controller(emu, controller_data);
+        util::set_controller(emu, button);
         emu.run_until_vblank();
     }
-    util::set_controller(emu, 0);
+    util::set_controller(emu, '.');
 }
 
 #[derive(PartialEq)]
diff --git a/tests/src/util.rs b/tests/src/util.rs
@@ -1,7 +1,6 @@
 use rusticnes_core::nes::NesState;
 use rusticnes_core::{ cartridge, opcodes, opcode_info };
-use minifb::{Key, KeyRepeat};
-use crate::{labels, video};
+use crate::{input, labels};
 
 pub fn emulator(rom: Option<&[u8]>) -> NesState {
     let rom = rom.unwrap_or(include_bytes!("../../tetris.nes"));
@@ -12,43 +11,38 @@ pub fn emulator(rom: Option<&[u8]>) -> NesState {
     emu
 }
 
-pub fn run_n_vblanks(emu: &mut NesState, n: i32) {
+pub fn run_n_vblanks(emu: &mut NesState, n: usize) {
     for _ in 0..n {
         emu.run_until_vblank();
     }
 }
 
-/// debug helper for showing the current visual state.
-/// hotkeys: 'q' closes window, 's' steps by a frame
-#[allow(dead_code)]
-pub fn preview(emu: &mut NesState) {
-    let mut view = video::Video::new();
-    view.window.set_key_repeat_rate(0.1);
-    loop {
-        if !view.window.is_open() {
-            break;
-        }
-        if view.window.is_key_pressed(Key::Q, KeyRepeat::No) {
-            break;
-        }
-        if view.window.is_key_pressed(Key::S, KeyRepeat::Yes) {
-            emu.run_until_vblank();
-        }
-        view.render(emu);
-    }
-}
-
 // emu.p1_input inverts the traditional bit assignments for the controller
 // (e.g. 0x01 corresponds to A) to more accurately emulate how bits are read
 // in.
-pub fn set_controller(emu: &mut NesState, buttons: u8) {
+pub fn set_controller_raw(emu: &mut NesState, buttons: u8) {
     let mut flipped_buttons = 0u8;
     for i in 0..8 {
         flipped_buttons |= ((buttons >> i) & 1) << (7-i);
     }
     emu.p1_input = flipped_buttons;
 }
 
+pub fn set_controller(emu: &mut NesState, button: char) {
+    set_controller_raw(emu, match button {
+        'L' => input::LEFT,
+        'R' => input::RIGHT,
+        'D' => input::DOWN,
+        'U' => input::UP,
+        'A' => input::A,
+        'B' => input::B,
+        'S' => input::START,
+        'T' => input::SELECT,
+        '.' => 0,
+        _ => panic!("character '{}' cannot be used as controller input", button),
+    });
+}
+
 pub fn run_to_return(emu: &mut NesState, print: bool) {
     opcodes::push(emu, 0);
     opcodes::push(emu, 0);
@@ -90,6 +84,65 @@ pub fn cycles_to_return(emu: &mut NesState) -> u32 {
     cycles
 }
 
+pub fn cycles_to_vblank(emu: &mut NesState) -> u32 {
+    let vblank = labels::get("verticalBlankingInterval") as usize;
+    let mut cycles = 0;
+    let mut done = false;
+
+    while emu.ppu.current_scanline == 242 {
+        emu.cycle();
+        if !done {
+            cycles += 1;
+            if emu.memory.iram_raw[vblank] == 1 {
+                done = true;
+            }
+        }
+        let mut i = 0;
+        while emu.cpu.tick >= 1 && i < 10 {
+            emu.cycle();
+            if !done {
+                cycles += 1;
+                if emu.memory.iram_raw[vblank] == 1 {
+                    done = true;
+                }
+            }
+            i += 1;
+        }
+        if emu.ppu.current_frame != emu.last_frame {
+            emu.event_tracker.swap_buffers();
+            emu.last_frame = emu.ppu.current_frame;
+        }
+    }
+    emu.memory.iram_raw[vblank] = 1;
+    done = false;
+    while emu.ppu.current_scanline != 242 {
+        emu.cycle();
+        if !done {
+            cycles += 1;
+            if emu.memory.iram_raw[vblank] == 0 {
+                done = true;
+            }
+        }
+        let mut i = 0;
+        while emu.cpu.tick >= 1 && i < 10 {
+            emu.cycle();
+            if !done {
+                cycles += 1;
+                if emu.memory.iram_raw[vblank] == 0 {
+                    done = true;
+                }
+            }
+            i += 1;
+        }
+        if emu.ppu.current_frame != emu.last_frame {
+            emu.event_tracker.swap_buffers();
+            emu.last_frame = emu.ppu.current_frame;
+        }
+    }
+
+    cycles
+}
+
 pub fn print_step(emu: &mut NesState) {
     if let Some(label) = labels::from_addr(emu.registers.pc) {
         println!("{}:", label);
diff --git a/tests/src/video.rs b/tests/src/video.rs
@@ -1,5 +1,5 @@
 use rusticnes_core::nes::NesState;
-use minifb::{Window, WindowOptions};
+use minifb::{Window, WindowOptions, Key, KeyRepeat};
 
 pub const WIDTH: usize = 256;
 pub const HEIGHT: usize = 240;
@@ -30,3 +30,23 @@ impl Video {
         self.window.update_with_buffer(&emu.ppu.filtered_screen, WIDTH, HEIGHT).unwrap();
     }
 }
+
+/// debug helper for showing the current visual state.
+/// hotkeys: 'q' closes window, 's' steps by a frame
+#[allow(dead_code)]
+pub fn preview(emu: &mut NesState) {
+    let mut view = Video::new();
+    view.window.set_key_repeat_rate(0.1);
+    loop {
+        if !view.window.is_open() {
+            break;
+        }
+        if view.window.is_key_pressed(Key::Q, KeyRepeat::No) {
+            break;
+        }
+        if view.window.is_key_pressed(Key::S, KeyRepeat::Yes) {
+            emu.run_until_vblank();
+        }
+        view.render(emu);
+    }
+}
