Merge branch 'tests'

Author: kirjavascript

.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,19 @@
+#[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),
+        }
+    }
+}

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,47 @@
+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();
+
+    if options.test {
+        pushdown::test();
+        println!("pushdown works!");
+    }
+
+    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,31 @@
+use rusticnes_core::nes::NesState;
+use crate::{labels, util, block};
+
+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()
+    }
+}

tests/src/sps.rs

@@ -0,0 +1,64 @@
+use rusticnes_core::nes::NesState;
+use rusticnes_core::{ cartridge, opcodes, opcode_info };
+use crate::labels;
+
+pub fn emulator(rom: Option<&[u8]>) -> NesState {
+    let rom = rom.unwrap_or(include_bytes!("../../tetris.nes"));
+    let mut emu = NesState::new(Box::new(cartridge::mapper_from_file(rom)).unwrap());
+
+    emu.power_on();
+
+    emu
+}
+
+pub fn run_to_return(emu: &mut NesState, print: bool) {
+    opcodes::push(emu, 0);
+    opcodes::push(emu, 0);
+
+    loop {
+        if print {
+            print_step(emu);
+        } else {
+            emu.step();
+        }
+
+        if emu.registers.pc < 3 {
+            break;
+        }
+    }
+}
+
+pub fn print_step(emu: &mut NesState) {
+    if let Some(label) = labels::from_addr(emu.registers.pc) {
+        println!("{}:", label);
+    }
+
+    print!("{:x} ", emu.registers.pc);
+
+    emu.step();
+
+    println!("{}", opcode_info::disassemble_instruction(emu.cpu.opcode, 0, 0).0);
+}
+
+pub fn set_score(emu: &mut NesState, score: u32) {
+    let score_addr = labels::get("score");
+    let binscore_addr = labels::get("binScore");
+    let bcd_str = format!("{:06}", 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();
+
+    emu.memory.iram_raw[(score_addr + 2) as usize] = bcd_a as u8;
+    emu.memory.iram_raw[(score_addr + 1) as usize] = bcd_b as u8;
+    emu.memory.iram_raw[score_addr as usize] = bcd_c 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;
+}
+
+pub fn get_score(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)
+}