Verbatim/tests/determinism.rs

use verbatim::ai::GameSession;
use verbatim::ai::AiAction;
use verbatim::ai::ReplayPlayer;

fn setup() -> GameSession {
    let mut s = GameSession::new_seeded(42);
    s.init_empty();
    s.clear_area(90, 90, 50, 50);
    s.perform_action(&AiAction::FillRect { x: 80, y: 130, w: 80, h: 15, material: "stone".into() });
    s
}

#[test]
fn same_seed_same_player_position() {
    let mut s1 = GameSession::new_seeded(777);
    s1.init();
    s1.step(30);
    let mut s2 = GameSession::new_seeded(777);
    s2.init();
    s2.step(30);
    let p1 = s1.get_player().unwrap();
    let p2 = s2.get_player().unwrap();
    assert!((p1.pos[0] - p2.pos[0]).abs() < 0.01, "x mismatch");
    assert!((p1.pos[1] - p2.pos[1]).abs() < 0.01, "y mismatch");
}

#[test]
fn same_seed_same_entity_count() {
    let mut s1 = GameSession::new_seeded(555);
    s1.init();
    s1.step(60);
    let mut s2 = GameSession::new_seeded(555);
    s2.init();
    s2.step(60);
    assert_eq!(s1.get_entities().len(), s2.get_entities().len(), "entity count should match");
}

#[test]
fn same_seed_same_grid_state() {
    let mut s1 = GameSession::new_seeded(333);
    s1.init();
    s1.step(20);
    let mut s2 = GameSession::new_seeded(333);
    s2.init();
    s2.step(20);
    for y in 100..150 {
        for x in 100..150 {
            let c1 = s1.get_cell(x, y);
            let c2 = s2.get_cell(x, y);
            assert_eq!(c1.material, c2.material, "material mismatch at ({},{})", x, y);
        }
    }
}

// Note: different seeds currently produce the same world because
// the CA RNG is internal (not seeded from GameSession).
// This is a known limitation — world gen is deterministic regardless of seed.
// Seed matters for replay recording/determinism within a session.

#[test]
fn replay_exact_match() {
    let mut s = GameSession::new_seeded(888);
    s.init();
    s.set_recording(true);
    s.perform_action(&AiAction::MoveRight);
    s.step(10);
    s.perform_action(&AiAction::Jump);
    s.step(10);
    s.perform_action(&AiAction::MoveLeft);
    s.step(10);
    let state_orig = s.get_state();
    s.save_replay("/tmp/verbatim_replay_exact.json").expect("save");

    let player = ReplayPlayer::load("/tmp/verbatim_replay_exact.json").expect("load");
    let s2 = player.play();
    let state_replay = s2.get_state();

    assert_eq!(state_orig.tick, state_replay.tick, "tick mismatch");
    if let (Some(p1), Some(p2)) = (&state_orig.player, &state_replay.player) {
        assert!((p1.pos[0] - p2.pos[0]).abs() < 0.1, "x mismatch: {} vs {}", p1.pos[0], p2.pos[0]);
        assert!((p1.pos[1] - p2.pos[1]).abs() < 0.1, "y mismatch: {} vs {}", p1.pos[1], p2.pos[1]);
        assert!((p1.health - p2.health).abs() < 1.0, "health mismatch");
    }
}

#[test]
fn replay_stop_at_tick() {
    let mut s = GameSession::new_seeded(444);
    s.init();
    s.set_recording(true);
    s.step(20);
    s.perform_action(&AiAction::MoveRight);
    s.step(20);
    s.save_replay("/tmp/verbatim_replay_partial.json").expect("save");

    let player = ReplayPlayer::load("/tmp/verbatim_replay_partial.json").expect("load");
    let s_half = player.play_until_tick(10);
    assert_eq!(s_half.tick(), 10, "should stop at tick 10, got {}", s_half.tick());

    let s_full = player.play();
    assert_eq!(s_full.tick(), 40, "full replay should reach tick 40, got {}", s_full.tick());
}

#[test]
fn recording_captures_all_actions() {
    let mut s = GameSession::new_seeded(123);
    s.init();
    s.set_recording(true);
    s.perform_action(&AiAction::MoveRight);
    s.perform_action(&AiAction::Jump);
    s.perform_action(&AiAction::MoveLeft);
    s.step(5);
    s.save_replay("/tmp/verbatim_replay_capture.json").expect("save");

    let player = ReplayPlayer::load("/tmp/verbatim_replay_capture.json").expect("load");
    let event_count = player.recording().events.len();
    assert!(event_count >= 4, "recording should have at least 4 events (3 actions + 1 step), got {}", event_count);
}

#[test]
fn determinism_with_spawn_and_damage() {
    let mut s1 = setup();
    s1.perform_action(&AiAction::Spawn { kind: "goblin".into(), x: 135.0, y: 120.0 });
    s1.perform_action(&AiAction::DamageEntity { id: 1, amount: 20.0 });
    s1.step(30);

    let mut s2 = setup();
    s2.perform_action(&AiAction::Spawn { kind: "goblin".into(), x: 135.0, y: 120.0 });
    s2.perform_action(&AiAction::DamageEntity { id: 1, amount: 20.0 });
    s2.step(30);

    let e1 = s1.get_entities().into_iter().find(|e| e.id == 1).unwrap();
    let e2 = s2.get_entities().into_iter().find(|e| e.id == 1).unwrap();
    assert!((e1.health - e2.health).abs() < 0.01, "health should match: {} vs {}", e1.health, e2.health);
    assert!((e1.pos[0] - e2.pos[0]).abs() < 0.1, "x should match");
    assert!((e1.pos[1] - e2.pos[1]).abs() < 0.1, "y should match");
}

#[test]
fn hundred_tick_determinism() {
    let mut s1 = GameSession::new_seeded(99);
    s1.init();
    s1.perform_action(&AiAction::MoveRight);
    s1.step(100);

    let mut s2 = GameSession::new_seeded(99);
    s2.init();
    s2.perform_action(&AiAction::MoveRight);
    s2.step(100);

    let p1 = s1.get_player().unwrap();
    let p2 = s2.get_player().unwrap();
    assert!((p1.pos[0] - p2.pos[0]).abs() < 0.01, "100-tick determinism failed: {} vs {}", p1.pos[0], p2.pos[0]);
}