//! The mod's headless scenarios run against the SDK-independent package too. extern crate airdef_core as airdef; #[path = "../../airdef-mod/examples/sim_run/harness.rs"] mod harness; fn check(sc: harness::Scenario) -> harness::Report { let r = harness::run(&sc); let problems = r.problems(); assert!(problems.is_empty(), "scenario {} failed: {problems:?}\n{}", r.name, r.text()); assert!(r.launched > 0); r } #[test] fn big_smart_raid_on_61_systems() { let r = check(harness::big_smart()); assert_eq!(r.units, 61); assert!(r.fired > 0 && r.ground_queries > 0); } #[test] fn logistics_trucks_depot_and_raid() { let r = check(harness::logistics()); assert!(r.truck_busy_ticks > 0 && r.fired > 0); } #[test] fn ew_and_adaptive_enemy_over_three_raids() { assert_eq!(check(harness::ew_adaptive()).raids_ended, 3); } #[test] fn same_seed_same_result() { let a = harness::run(&harness::logistics()); let b = harness::run(&harness::logistics()); assert_eq!((a.ticks_run, a.launched, a.kills, a.hits, a.fired, a.ground_queries), (b.ticks_run, b.launched, b.kills, b.hits, b.fired, b.ground_queries)); } #[test] fn overlapping_mass_strikes_on_flat_world() { use airdef::sim::{Aim, Approach, DroneKind as D, Ground, Out, RaidOrder, Sam, Sim}; use glam::DVec3; let sc = harness::big_smart(); let terrain = harness::Terrain::Flat(70); let mut sim = Sim::new(sc.seed); sim.damage = false; for unit in &sc.units { let id = sim.id(); sim.sams.push(Sam::new(id, unit.kind, DVec3::new(unit.pos.x, 70.0, unit.pos.z), unit.heading)); } sim.targets = vec![DVec3::new(0.0, 70.0, 0.0)]; sim.target_health = vec![100.0]; // Exact composition of the menu's "Массированный удар" preset. let order = RaidOrder { kinds: vec![(D::Gerbera, 8), (D::Shahed, 12), (D::Geran3, 4), (D::Kh101, 4), (D::Kalibr, 4), (D::Kh22, 2), (D::Iskander, 2)], approach: Approach::AllSides, aim: Aim::Smart, dist: 4000.0 }; let mut ground = Ground::default(); let mut pending = Vec::new(); let mut out = Out::default(); let targets = sim.targets.clone(); assert_eq!(sim.order_raid(&order, &targets, &mut out), 36); let mut second = false; let mut peak = 0; for now in 1..=12000 { if !second && !sim.planning() { assert_eq!(sim.order_raid(&order, &targets, &mut out), 36); second = true; } ground.answer(std::mem::take(&mut pending), now); out = Out::default(); sim.step(&mut ground, None, &mut out); let wanted = ground.take_wanted(); pending = wanted.into_iter().map(|(x, z)| (x, z, 70)).collect(); let sections = ground.world.take_wanted(now); ground.world.serve(&terrain, sections, now); peak = peak.max(sim.drones.iter().filter(|d| d.alive()).count()); assert!(sim.drones.iter().all(|d| d.pos.is_finite() && d.vel.is_finite())); if sim.launched >= 72 && peak > 36 { break; } } eprintln!("overlapping mass strikes: launched {}, peak airborne {peak}", sim.launched); assert!(second && sim.launched >= 72, "second raid failed to launch; launched {}", sim.launched); assert!(peak > 36, "raids never overlapped; peak {peak}"); } #[test] fn overlapping_oreshnik_splits_are_recorded() { use airdef::sim::{Aim, Approach, DroneKind, Ground, Out, RaidOrder, Sim}; use glam::DVec3; let mut sim = Sim::new(1); sim.damage = false; let targets = vec![DVec3::new(0.0, 70.0, 0.0)]; sim.targets = targets.clone(); sim.target_health = vec![100.0]; let order = RaidOrder { kinds: vec![(DroneKind::Oreshnik, 40)], approach: Approach::Sector, aim: Aim::Objects, dist: 2600.0 }; let terrain = harness::Terrain::Flat(70); let mut ground = Ground::default(); let mut pending = Vec::new(); let mut out = Out::default(); assert_eq!(sim.order_raid(&order, &targets, &mut out), 40); let mut second = false; let mut peak = 0; let mut peak_subs = 0; for now in 1..=10000 { if !second && !sim.planning() { assert_eq!(sim.order_raid(&order, &targets, &mut out), 40); second = true; } ground.answer(std::mem::take(&mut pending), now); out = Out::default(); sim.step(&mut ground, None, &mut out); pending = ground.take_wanted().into_iter().map(|(x, z)| (x, z, 70)).collect(); let sections = ground.world.take_wanted(now); ground.world.serve(&terrain, sections, now); peak = peak.max(sim.drones.iter().filter(|d| d.alive()).count()); peak_subs = peak_subs.max(sim.drones.iter().filter(|d| d.alive() && d.kind == DroneKind::OreshnikSub).count()); assert!(sim.drones.iter().all(|d| d.pos.is_finite() && d.vel.is_finite())); if second && sim.launched >= 80 && !sim.replays.is_empty() { break; } } eprintln!("overlapping oreshnik: launched {}, peak airborne {peak}, peak submunitions {peak_subs}, replays {}", sim.launched, sim.replays.len()); assert_eq!(sim.launched, 2880); assert!(peak_subs > 36, "expected many simultaneous submunitions"); assert!(!sim.replays.is_empty(), "recording did not finish"); } #[test] fn two_maximum_menu_raids_with_answered_flat_terrain() { use airdef::sim::{Aim, Approach, Ground, Out, RaidOrder, Sam, Sim, catalog::RAID_KINDS}; use glam::DVec3; let sc = harness::big_smart(); let terrain = harness::Terrain::Flat(70); let mut sim = Sim::new(sc.seed); for unit in &sc.units { let id = sim.id(); sim.sams.push(Sam::new(id, unit.kind, DVec3::new(unit.pos.x, 70.0, unit.pos.z), unit.heading)); } let targets = vec![DVec3::new(0.0, 70.0, 0.0)]; sim.targets = targets.clone(); sim.target_health = vec![100.0]; // The maximum selectable by the menu: 40 for each raid kind. let order = RaidOrder { kinds: RAID_KINDS.iter().copied().map(|kind| (kind, 40)).collect(), approach: Approach::AllSides, aim: Aim::Smart, dist: 300.0 }; let expected = RAID_KINDS.len() as u32 * 40; let mut ground = Ground::default(); let mut pending = Vec::new(); let mut out = Out::default(); assert_eq!(sim.order_raid(&order, &targets, &mut out), expected); let mut second = false; let mut overlap = false; let mut peak = 0; for now in 1..=5000 { if !second && !sim.planning() { overlap = !sim.queue.is_empty() || sim.drones.iter().any(|d| d.alive()); assert_eq!(sim.order_raid(&order, &targets, &mut out), expected); second = true; } ground.answer(std::mem::take(&mut pending), now); out = Out::default(); sim.step(&mut ground, None, &mut out); pending = ground.take_wanted().into_iter().map(|(x, z)| (x, z, 70)).collect(); let sections = ground.world.take_wanted(now); ground.world.serve(&terrain, sections, now); peak = peak.max(sim.drones.iter().filter(|d| d.alive()).count()); assert!(sim.drones.iter().all(|d| d.pos.is_finite() && d.vel.is_finite())); if second && sim.launched >= expected * 2 && !sim.replays.is_empty() { break; } } eprintln!("max menu raids: requested {}, launched {}, peak {peak}, replays {}", expected * 2, sim.launched, sim.replays.len()); assert!(second && overlap && sim.launched >= expected * 2 && peak > 40); assert!(!sim.replays.is_empty(), "raid recording did not finish"); }