cc48302b36
Co-authored-by: Codex <codex@openai.com>
167 lines
7.3 KiB
Rust
167 lines
7.3 KiB
Rust
//! 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");
|
|
}
|