Squashed commit of the following:

commit da3b132
Author: kirjavascript <[email protected]>
Date:   Fri Jan 5 02:05:22 2024 +0000

    test wording

commit c8e92b4
Author: kirjavascript <[email protected]>
Date:   Fri Jan 5 01:11:45 2024 +0000

    test sps

commit ae0eb46
Merge: afd957f 1ca31c1
Author: kirjavascript <[email protected]>
Date:   Thu Jan 4 23:52:42 2024 +0000

    Merge branch 'tests'

commit 1ca31c1
Author: kirjavascript <[email protected]>
Date:   Thu Jan 4 23:52:25 2024 +0000

    add SPS tests

commit 178875d
Author: kirjavascript <[email protected]>
Date:   Tue Jan 2 00:28:20 2024 +0000

    SPS to tests

commit 91e45bc
Author: kirjavascript <[email protected]>
Date:   Sat Dec 30 17:45:19 2023 +0000

    read addresses from debug info

commit b9a086e
Author: kirjavascript <[email protected]>
Date:   Sat Dec 30 03:42:06 2023 +0000

    add pushdown points test

commit 79686df
Author: kirjavascript <[email protected]>
Date:   Sat Dec 30 03:01:52 2023 +0000

    basic emulator testing framework

commit afd957f
Author: kirjavascript <[email protected]>
Date:   Fri Dec 29 22:48:11 2023 +0000

    readme note

commit d49df68
Author: kirjavascript <[email protected]>
Date:   Fri Dec 29 22:39:52 2023 +0000

    initial test framework

Author: zohassadar

.gitignore

@@ -9,3 +9,4 @@ tetris.lbl
 tetris.map
 tetris.dbg
 release/*
+target

tests/Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "gym-tests"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+gumdrop = "0.8.1"
+rusticnes-core = { git = "https://github.com/zeta0134/rusticnes-core.git", version = "0.2.0" }

tests/Cargo.toml

@@ -0,0 +1,34 @@
+#[derive(Debug, PartialEq)]
+pub enum Block {
+    T, J, Z, O, S, L, I, Unknown(u8)
+}
+
+impl From<u8> for Block {
+    fn from(value: u8) -> Self {
+        match value {
+            0x2 => Block::T,
+            0x7 => Block::J,
+            0x8 => Block::Z,
+            0xA => Block::O,
+            0xB => Block::S,
+            0xE => Block::L,
+            0x12 => Block::I,
+            _ => Block::Unknown(value),
+        }
+    }
+}
+
+impl From<char> for Block {
+    fn from(value: char) -> Self {
+        match value {
+            'T' => Block::T,
+            'J' => Block::J,
+            'Z' => Block::Z,
+            'O' => Block::O,
+            'S' => Block::S,
+            'L' => Block::L,
+            'I' => Block::I,
+            _ => Block::Unknown(value as u8),
+        }
+    }
+}

tests/src/block.rs

@@ -0,0 +1,73 @@
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+fn parse_debug_line(line: &str) -> (String, u16) {
+    let pairs: Vec<&str> = line.split(',').collect();
+
+    let mut name = String::new();
+    let mut val = 0;
+
+    for pair in pairs {
+        let key_val: Vec<&str> = pair.split('=').collect();
+        if key_val.len() == 2 {
+            let key = key_val[0].trim();
+            let value = key_val[1].trim();
+
+            match key {
+                "name" => name = value.trim_matches('"').to_string(),
+                "val" => {
+                    if let Ok(hex_value) = u16::from_str_radix(value.trim_start_matches("0x"), 16) {
+                        val = hex_value;
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    (name, val)
+}
+
+fn labels() -> &'static HashMap<String, u16> {
+    static LABELS: OnceLock<HashMap<String, u16>> = OnceLock::new();
+    LABELS.get_or_init(|| {
+        let text = include_str!("../../tetris.dbg");
+        let mut labels: HashMap<String, u16> = HashMap::new();
+
+        for line in text.lines() {
+            let (name, val) = parse_debug_line(line);
+
+            if !name.is_empty() {
+                labels.insert(name, val);
+            }
+        }
+
+        labels
+    })
+}
+
+fn addrs() -> &'static HashMap<u16, String> {
+    static LABELS: OnceLock<HashMap<u16, String>> = OnceLock::new();
+    LABELS.get_or_init(|| {
+        let text = include_str!("../../tetris.dbg");
+        let mut labels: HashMap<u16, String> = HashMap::new();
+
+        for line in text.lines() {
+            let (name, val) = parse_debug_line(line);
+
+            if !name.is_empty() {
+                labels.insert(val, name);
+            }
+        }
+
+        labels
+    })
+}
+
+pub fn get(label: &str) -> u16 {
+    *labels().get(label).expect(&format!("label {} not found", label))
+}
+
+pub fn from_addr(addr: u16) -> Option<&'static String> {
+    addrs().get(&addr)
+}

tests/src/labels.rs

@@ -0,0 +1,51 @@
+mod labels;
+mod pushdown;
+mod util;
+mod block;
+mod sps;
+
+use gumdrop::Options;
+
+fn parse_hex(s: &str) -> Result<u32, std::num::ParseIntError> {
+    u32::from_str_radix(s, 16)
+}
+
+#[derive(Debug, Options)]
+struct TestOptions {
+    help: bool,
+    #[options(help = "run tests")]
+    test: bool,
+    #[options(help = "set SPS seed", parse(try_from_str = "parse_hex"))]
+    sps_seed: u32,
+    #[options(help = "print SPS pieces")]
+    sps_qty: u32,
+}
+
+fn main() {
+    let options = TestOptions::parse_args_default_or_exit();
+
+    // run tests
+    if options.test {
+        sps::test();
+        println!("sps is the same!");
+        pushdown::test();
+        println!("pushdown works!");
+    }
+
+    // print SPS sequences
+    if options.sps_qty > 0 {
+        let mut blocks = sps::SPS::new();
+
+        blocks.set_input((
+            ((options.sps_seed >> 16) & 0xFF) as u8,
+            ((options.sps_seed >> 8) & 0xFF) as u8,
+            (options.sps_seed& 0xFF) as u8,
+        ));
+
+        for i in 0..options.sps_qty {
+            print!("{:?}", blocks.next());
+        }
+    }
+
+    // TODO: cycle counts for modes
+}

tests/src/main.rs

@@ -0,0 +1,45 @@
+use crate::{labels, util};
+
+pub fn test() {
+    let mut emu = util::emulator(None);
+
+    for pushdown in 2..15 {
+        [0..1000, 24500..25500].into_iter().for_each(|range| {
+            for score in range {
+                util::set_score(&mut emu, score);
+
+                emu.registers.pc = labels::get("addPushDownPoints");
+                emu.memory.iram_raw[labels::get("holdDownPoints") as usize] = pushdown;
+
+                util::run_to_return(&mut emu, false);
+
+                let reference = pushdown_impl(pushdown, score as u16) as u32;
+
+                assert_eq!(reference, util::get_score(&mut emu) - score);
+            }
+        });
+    }
+}
+
+// reference implementation - tested against the original game
+// may seem weird - designed to be translated to assembly
+fn pushdown_impl(pushdown: u8, score: u16) -> u16 {
+    let ones = score % 10;
+    let hundredths = score % 100;
+    let mut newscore = ones as u8 + (pushdown - 1);
+    if newscore & 0xF > 9 {
+        newscore += 6;
+    }
+
+    let low = (newscore & 0xF) as u16;
+    let high = ((newscore & 0xF0) / 16 * 10) as u16;
+
+    let mut newscore = high + (hundredths - ones);
+    let nextscore = newscore + low;
+
+    if nextscore <= 100 {
+        newscore = nextscore;
+    }
+
+    newscore + (score - hundredths) - score
+}

tests/src/pushdown.rs

@@ -0,0 +1,55 @@
+use crate::{block, labels, util};
+use rusticnes_core::nes::NesState;
+
+pub struct SPS {
+    emu: NesState,
+}
+
+impl SPS {
+    pub fn new() -> Self {
+        Self {
+            emu: util::emulator(None),
+        }
+    }
+
+    pub fn set_input(&mut self, seed: (u8, u8, u8)) {
+        self.emu.memory.iram_raw[(labels::get("set_seed_input") + 0) as usize] = seed.0;
+        self.emu.memory.iram_raw[(labels::get("set_seed") + 0) as usize] = seed.0;
+        self.emu.memory.iram_raw[(labels::get("set_seed_input") + 1) as usize] = seed.1;
+        self.emu.memory.iram_raw[(labels::get("set_seed") + 1) as usize] = seed.1;
+        self.emu.memory.iram_raw[(labels::get("set_seed_input") + 2) as usize] = seed.2;
+        self.emu.memory.iram_raw[(labels::get("set_seed") + 2) as usize] = seed.2;
+    }
+
+    pub fn next(&mut self) -> block::Block {
+        self.emu.registers.pc = labels::get("pickTetriminoSeed");
+
+        util::run_to_return(&mut self.emu, false);
+
+        self.emu.memory.iram_raw[labels::get("spawnID") as usize].into()
+    }
+}
+
+pub fn test() {
+    let mut blocks = SPS::new();
+
+    blocks.set_input((0x10, 0x10, 0x10));
+    "ZJOTLTZJLZJSZISIJOLITJSILZJILITSISZOITIZSZJLLTIOZJZSZISIJZTIZJTSOJSJISJOOTSJTOTZSZTZSLTZTOTSIZJZIJIL".chars().for_each(|block| {
+        assert_eq!(blocks.next(), block.into());
+    });
+
+    blocks.set_input((0x12, 0x34, 0x56));
+    "ZTZIJIJOZTSOSZJZOSLIOIJIJSTZSTTJISSTOIZJITJOZJITSOSZSJLTISJOITTLSLJTZTZOZSLJTJZSLTSOTLOJLSJSJTJILOJS".chars().for_each(|block| {
+        assert_eq!(blocks.next(), block.into());
+    });
+
+    blocks.set_input((0x87, 0xAB, 0x12));
+    "OZIJSOTZSJTSTJZLOLJOJISOZOIOZJITILSSJZLOIJSTITLSOJILTSOOLZOOIJOZLTLSISIJIJTOLSIJILSLOLJLTOSOSLOIZSIS".chars().for_each(|block| {
+        assert_eq!(blocks.next(), block.into());
+    });
+
+    blocks.set_input((0x13, 0x37, 0x02));
+    "OJSTZSIOLSIJTSZILJZJJLZLISISJTLZTSZTJOJOSJSZLITJOIOTITILTOSTJSZTSOOIOJSIITLJOZSIOJOTZTLJLIOJLITSSLSLIJIIOLOISLZJLIJJTIZIJOJISLTIJTOTZIOILSTTLTZIZJSOLOZOZOLOTZTZOTZOSIOTJJTSIZSOLTOLIZSOZOTZISLJTSZLOISO".chars().for_each(|block| {
+        assert_eq!(blocks.next(), block.into());
+    });
+}