engine_rust_src/src/bin/benchmark_pure.rs

use std::env;
use std::fs;
use std::time::Instant;
use engine_rust::core::logic::{CardDatabase, GameState};

fn main() {
    let args: Vec<String> = env::args().collect();
    let json_path = if args.len() > 1 { &args[1] } else { "../data/cards_compiled.json" };

    println!("Loading cards from {}...", json_path);
    let json_str = fs::read_to_string(json_path).expect("Failed to read cards JSON");
    let db = CardDatabase::from_json(&json_str).expect("Failed to parse JSON");
    println!("Database loaded. Members: {}", db.members.len());

    let all_members: Vec<u16> = db.members.keys().map(|&k| k as u16).collect();
    let all_lives: Vec<u16> = db.lives.keys().map(|&k| k as u16).collect();

    // Create a realistic populated state
    let p0_deck: Vec<u16> = all_members.iter().take(50).cloned().collect();
    let p1_deck: Vec<u16> = all_members.iter().skip(50).take(50).cloned().collect();
    let p0_lives: Vec<u16> = all_lives.iter().take(20).cloned().collect();
    let p1_lives: Vec<u16> = all_lives.iter().skip(20).take(20).cloned().collect();

    let mut game = GameState::default();
    game.initialize_game(
        p0_deck, p1_deck,
        vec![], vec![],
        p0_lives, p1_lives
    );
    game.silent = true;

    // Warmup
    for _ in 0..1000 {
        let _ = game.clone();
    }

    let iterations = 1_000_000;
    println!("Benchmarking GameState::clone() for {} iterations...", iterations);

    let start = Instant::now();
    for _ in 0..iterations {
        let _ = std::hint::black_box(game.clone());
    }
    let duration = start.elapsed();

    println!("Total time: {:.4} s", duration.as_secs_f64());
    println!("Latency per copy: {:.4} us", duration.as_secs_f64() * 1_000_000.0 / iterations as f64);
    println!("Ops/sec: {:.0}", iterations as f64 / duration.as_secs_f64());
}