Spaces:
Sleeping
Sleeping
File size: 5,755 Bytes
463f868 9bd4ce5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 | /// diagnostic_init.rs — Game Initialization Diagnostic
///
/// Run with: cargo run --bin diagnostic_init [--release]
///
/// Purpose: Diagnose why games are failing to initialize properly
use std::fs;
use engine_rust::core::enums::Phase;
use engine_rust::core::logic::{GameState, CardDatabase};
use rand::SeedableRng;
use rand::seq::IndexedRandom;
fn load_vanilla_db() -> CardDatabase {
let candidates = [
"data/cards_vanilla.json",
"../data/cards_vanilla.json",
"../../data/cards_vanilla.json",
];
for path in &candidates {
if !std::path::Path::new(path).exists() {
continue;
}
let abs = std::fs::canonicalize(path)
.unwrap_or_else(|_| std::path::PathBuf::from(path));
println!("[DB_LOAD] Loading from: {:?}", abs);
let json = fs::read_to_string(path).expect("Failed to read vanilla DB");
let mut db = CardDatabase::from_json(&json).expect("Failed to parse vanilla DB");
db.is_vanilla = true;
return db;
}
panic!("Could not find cards_vanilla.json");
}
fn main() {
println!("Game Initialization Diagnostic\n");
let db = load_vanilla_db();
println!("DB loaded: {} members, {} lives, {} energy",
db.members.len(), db.lives.len(), db.energy_db.len());
// Get sample cards
let members: Vec<i32> = db.members.keys().take(48).cloned().collect();
let lives: Vec<i32> = db.lives.keys().take(12).cloned().collect();
let energy: Vec<i32> = db.energy_db.keys().take(12).cloned().collect();
if members.is_empty() || lives.is_empty() || energy.is_empty() {
eprintln!("ERROR: Not enough cards loaded!");
eprintln!(" Members: {}", members.len());
eprintln!(" Lives: {}", lives.len());
eprintln!(" Energy: {}", energy.len());
return;
}
println!("\n✓ Sample decks created");
println!(" Members: {}", members.len());
println!(" Lives: {}", lives.len());
println!(" Energy: {}", energy.len());
// Initialize the game
let mut state = GameState::default();
println!("\nBefore initialize_game:");
println!(" Phase: {:?}", state.phase);
println!(" Current Player: {}", state.current_player);
println!(" Turn: {}", state.turn);
println!(" Terminal: {}", state.is_terminal());
state.initialize_game(
members.clone(),
members.clone(),
energy.clone(),
energy.clone(),
lives.clone(),
lives.clone(),
);
println!("\nAfter initialize_game:");
println!(" Phase: {:?}", state.phase);
println!(" Current Player: {}", state.current_player);
println!(" Turn: {}", state.turn);
println!(" Terminal: {}", state.is_terminal());
println!(" P0 Hand: {}", state.players[0].hand.len());
println!(" P1 Hand: {}", state.players[1].hand.len());
println!(" P0 Deck: {}", state.players[0].deck.len());
println!(" P1 Deck: {}", state.players[1].deck.len());
println!(" P0 Energy: {}", state.players[0].energy_zone.len());
println!(" P1 Energy: {}", state.players[1].energy_zone.len());
if state.is_terminal() {
println!("\n⚠️ Game is immediately terminal after initialize_game!");
println!(" Winner: P{}", state.get_winner());
return;
}
// Try advancing to Main phase with proper handling
state.ui.silent = true;
println!("\nAdvancing to Main phase:");
let mut count = 0;
const MAX_STEPS: usize = 100;
let mut rng = rand::rngs::SmallRng::from_os_rng();
while !state.is_terminal() && state.phase != Phase::Main && count < MAX_STEPS {
let phase_str = format!("{:?}", state.phase);
// Handle non-auto phases that require player actions
match state.phase {
Phase::Rps | Phase::MulliganP1 | Phase::MulliganP2 | Phase::TurnChoice | Phase::Response => {
// Get legal actions and pick one randomly
let legal = state.get_legal_action_ids(&db);
if !legal.is_empty() {
if let Some(&action) = legal.choose(&mut rng) {
if let Err(e) = state.step(&db, action as i32) {
println!(" Step {}: Phase = {:?} → step() error: {:?}", count, state.phase, e);
}
}
} else {
println!(" Step {}: Phase = {:?} → no legal actions!", count, phase_str);
break;
}
}
_ => {
// Auto-step for other phases
state.auto_step(&db);
}
}
count += 1;
if count <= 10 || count % 5 == 0 {
println!(" Step {}: Phase = {:?}", count, state.phase);
}
}
if count >= MAX_STEPS {
println!("⚠️ Reached MAX_STEPS limit!");
} else if state.is_terminal() {
println!("⚠️ Game became terminal!");
println!(" Final Phase: {:?}", state.phase);
} else {
println!("✓ Reached Main phase after {} steps", count);
println!(" Phase: {:?}", state.phase);
println!(" Legal actions: {}", state.get_legal_action_ids(&db).len());
}
println!("\nFinal state:");
println!(" P0 Score: {}", state.players[0].score);
println!(" P1 Score: {}", state.players[1].score);
println!(" P0 Success Lives: {}", state.players[0].success_lives.len());
println!(" P1 Success Lives: {}", state.players[1].success_lives.len());
println!(" Turn: {}", state.turn);
} |