test core score logic

Author: kirjavascript

tests/src/main.rs

@@ -36,6 +36,8 @@ fn main() {
 
     // run tests
     if options.test {
+        score::test();
+        println!("score works!");
         score::test_render();
         println!("score rendering works!");
         pushdown::test();

tests/src/pushdown.rs

@@ -5,7 +5,6 @@ pub fn test() {
 
     for pushdown in 2..15 {
         [0..1000, 24500..25500, 60000..65536].into_iter().for_each(|range| {
-        // [0..65535].into_iter().for_each(|range| {
             for score in range {
                 score::set(&mut emu, score);
 

tests/src/rng.rs

@@ -5,7 +5,8 @@ pub fn test() {
     assert_eq!(
         seeds(),
         include_str!("./rng_seeds.txt")
-            .split(',')
+            .trim()
+            .split('\n')
             .map(|s| s.trim().parse::<u16>().expect(s))
             .collect::<HashSet<_>>()
     );

tests/src/rng_seeds.txt

@@ -1,6 +1,65 @@
 use rusticnes_core::nes::NesState;
 use crate::{labels, score, util};
 
+pub fn set(emu: &mut NesState, score: u32) {
+    let score_addr = labels::get("score");
+    let binscore_addr = labels::get("binScore");
+    let bcd_str = format!("{:08}", score);
+    let bcd_a = i64::from_str_radix(&bcd_str[0..2], 16).unwrap();
+    let bcd_b = i64::from_str_radix(&bcd_str[2..4], 16).unwrap();
+    let bcd_c = i64::from_str_radix(&bcd_str[4..6], 16).unwrap();
+    let bcd_d = i64::from_str_radix(&bcd_str[6..8], 16).unwrap();
+
+    emu.memory.iram_raw[(score_addr + 3) as usize] = bcd_a as u8;
+    emu.memory.iram_raw[(score_addr + 2) as usize] = bcd_b as u8;
+    emu.memory.iram_raw[(score_addr + 1) as usize] = bcd_c as u8;
+    emu.memory.iram_raw[score_addr as usize] = bcd_d as u8;
+    emu.memory.iram_raw[binscore_addr as usize] = score as u8;
+    emu.memory.iram_raw[(binscore_addr + 1) as usize] = (score >> 8) as u8;
+    emu.memory.iram_raw[(binscore_addr + 2) as usize] = (score >> 16) as u8;
+    emu.memory.iram_raw[(binscore_addr + 3) as usize] = (score >> 24) as u8;
+}
+
+pub fn get(emu: &mut NesState) -> u32 {
+    let binscore_addr = labels::get("binScore");
+    emu.memory.iram_raw[binscore_addr as usize] as u32
+        + ((emu.memory.iram_raw[(binscore_addr + 1) as usize] as u32) << 8)
+        + ((emu.memory.iram_raw[(binscore_addr + 2) as usize] as u32) << 16)
+}
+
+pub fn test() {
+    let mut emu = util::emulator(None);
+
+    let completed_lines = labels::get("completedLines") as usize;
+    let add_points = labels::get("addPointsRaw");
+    let level_number = labels::get("levelNumber") as usize;
+
+    let mut score = move |score: u32, lines: u8, level: u8| {
+        score::set(&mut emu, score);
+        emu.registers.pc = add_points;
+        emu.memory.iram_raw[completed_lines] = lines;
+        emu.memory.iram_raw[level_number] = level;
+        util::run_to_return(&mut emu, false);
+        score::get(&mut emu)
+    };
+
+    // check every linecount on every level
+    for level in 0..=255 {
+        for lines in 0..=4 {
+            assert_eq!(score(0, lines, level), score_impl(lines, level));
+        }
+    }
+
+    // check tetris value from lots of scores
+    for initial_score in 999000..=1001000 {
+        assert_eq!(score(initial_score, 4, 18), initial_score + score_impl(4, 18));
+    }
+}
+
+pub fn score_impl(lines: u8, level: u8) -> u32 {
+    [0, 40, 100, 300, 1200][lines as usize] * (level as u32 + 1)
+}
+
 pub fn test_render() {
     let mut emu = util::emulator(None);
 
@@ -26,16 +85,15 @@ pub fn test_render() {
 
     // check letter score rendering works
 
-    // for i in 250..262 {
-    //     let score = i * 100000;
+    for i in 0..256 { // TODO: fix breaking at 25.5m
+        let score = i * 100000;
 
-    //     score::set(&mut emu, score);
-    //     emu.registers.pc = labels::get("renderLettersScore");
-    //     util::run_to_return(&mut emu, false);
+        score::set(&mut emu, score);
+        emu.registers.pc = labels::get("renderLettersScore");
+        util::run_to_return(&mut emu, false);
 
-    //     // TODO: fix breaking at 25.5m
-    //     println!("{} {} {}", i, (i % 36) as u8, rendered_score(&mut emu)[0]);
-    // }
+        assert_eq!((i % 36) as u8, rendered_score(&mut emu)[0]);
+    }
 
     // check score cap works
 
@@ -53,29 +111,3 @@ pub fn test_render() {
         assert_ne!(vec![9, 9, 9, 9, 9, 9], rendered_score(&mut emu));
     }
 }
-
-pub fn set(emu: &mut NesState, score: u32) {
-    let score_addr = labels::get("score");
-    let binscore_addr = labels::get("binScore");
-    let bcd_str = format!("{:08}", score);
-    let bcd_a = i64::from_str_radix(&bcd_str[0..2], 16).unwrap();
-    let bcd_b = i64::from_str_radix(&bcd_str[2..4], 16).unwrap();
-    let bcd_c = i64::from_str_radix(&bcd_str[4..6], 16).unwrap();
-    let bcd_d = i64::from_str_radix(&bcd_str[6..8], 16).unwrap();
-
-    emu.memory.iram_raw[(score_addr + 3) as usize] = bcd_a as u8;
-    emu.memory.iram_raw[(score_addr + 2) as usize] = bcd_b as u8;
-    emu.memory.iram_raw[(score_addr + 1) as usize] = bcd_c as u8;
-    emu.memory.iram_raw[score_addr as usize] = bcd_d as u8;
-    emu.memory.iram_raw[binscore_addr as usize] = score as u8;
-    emu.memory.iram_raw[(binscore_addr + 1) as usize] = (score >> 8) as u8;
-    emu.memory.iram_raw[(binscore_addr + 2) as usize] = (score >> 16) as u8;
-    emu.memory.iram_raw[(binscore_addr + 3) as usize] = (score >> 24) as u8;
-}
-
-pub fn get(emu: &mut NesState) -> u32 {
-    let binscore_addr = labels::get("binScore");
-    emu.memory.iram_raw[binscore_addr as usize] as u32
-        + ((emu.memory.iram_raw[(binscore_addr + 1) as usize] as u32) << 8)
-        + ((emu.memory.iram_raw[(binscore_addr + 2) as usize] as u32) << 16)
-}