chexit
e7934a1ebb
Stage 2 of #127. A smart drone now carries why it is aimed where it is (Intent: plan, sead, react, replace) apart from the aim bookkeeping (unit, since, switches, confidence). Assignments are throttled per adaptive tick and per contact, a fresh disclosure replaces an aim only after a hold, within a switch cap and when the change is worth a new route, and a killed aim is replaced as a separate, lower-priority decision. The queue is bounded and taken by priority (plan > sead > react > replace); unknown land is no longer free in a replanned route. The autosave now carries the air state: the drones in flight, the launch queue, every pending job with its id, aim, unit, version, priority, intent and relief version, the contacts the jobs were chosen from and the relief snapshots they plan over. The format is a versioned `air 1` section; older saves read as before, scenarios do not carry the sky, stale, ghost and duplicate jobs are cancelled on load, and the section is bounded (512 drones, 512 route points, 4096 contacts, 8 reliefs, 900 KB). A periodic save waits while a raid is only being planned. enemy_picture() now explains targets and pending jobs (aims, aimed_by, pending_jobs, reason, work_per_tick) in English, and intel_bench records the queue and intent evidence next to completion, losses and failures.
476 lines
18 KiB
Rust
476 lines
18 KiB
Rust
//! Headless driver for the pure simulation (`airdef::sim`): builds a scenario, steps the
|
|
//! simulation like the mod's tick does (answering ground queries from a height function),
|
|
//! and measures. Shared by the `sim_run` example and `tests/scenarios.rs`.
|
|
//!
|
|
//! Native timings say nothing about the WASM build or the GPU; use them to compare runs of the
|
|
//! same machine.
|
|
#![allow(dead_code)]
|
|
#[path = "../../src/world_view.rs"]
|
|
mod world_view;
|
|
use airdef::sim::{Aim, Approach, DroneKind, Ground, Out, RaidOrder, Sam, SamKind, Sim};
|
|
use glam::DVec3;
|
|
use std::collections::HashMap;
|
|
use std::time::{Duration, Instant};
|
|
|
|
/// Height of the land under a column (what `render.ground` would answer).
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub enum Terrain {
|
|
Flat(i32),
|
|
/// Smooth hills: `base + amp * (sin(x/period) + cos(z/period)) / 2`.
|
|
Hills { base: i32, amp: f64, period: f64 },
|
|
}
|
|
|
|
/// The land as blocks: solid at and below the column's height (what the game would answer `render.sections` with).
|
|
impl airdef::sim::world::WorldSource for Terrain {
|
|
fn solid(&self, x: i32, y: i32, z: i32) -> Option<bool> {
|
|
Some(y < self.height(x, z))
|
|
}
|
|
}
|
|
|
|
impl Terrain {
|
|
pub fn height(self, x: i32, z: i32) -> i32 {
|
|
match self {
|
|
Terrain::Flat(h) => h,
|
|
Terrain::Hills { base, amp, period } => {
|
|
base + (amp * ((f64::from(x) / period).sin() + (f64::from(z) / period).cos()) / 2.0).round() as i32
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct RaidSpec {
|
|
pub kinds: Vec<(DroneKind, u32)>,
|
|
pub approach: Approach,
|
|
pub aim: Aim,
|
|
pub dist: f64,
|
|
/// The tick the raid is ordered at (a raid waits for the previous one to be sent).
|
|
pub at: u64,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Unit {
|
|
pub kind: SamKind,
|
|
pub pos: DVec3,
|
|
pub heading: f64,
|
|
/// Starts with an empty magazine, waiting for a reload (logistics).
|
|
pub empty: bool,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Scenario {
|
|
pub name: String,
|
|
pub seed: u64,
|
|
pub units: Vec<Unit>,
|
|
pub objects: Vec<DVec3>,
|
|
pub raids: Vec<RaidSpec>,
|
|
pub terrain: Terrain,
|
|
/// Hard limit of ticks (20 a second).
|
|
pub ticks: u64,
|
|
/// Stop as soon as every raid has ended.
|
|
pub stop_at_end: bool,
|
|
pub ew: bool,
|
|
/// Ticks a truck on a job may stand still before it counts as stuck.
|
|
pub stuck_after: u64,
|
|
}
|
|
|
|
impl Scenario {
|
|
pub fn new(name: &str) -> Self {
|
|
Scenario {
|
|
name: name.into(),
|
|
seed: 1,
|
|
units: Vec::new(),
|
|
objects: vec![DVec3::new(0.0, 70.0, 0.0)],
|
|
raids: Vec::new(),
|
|
terrain: Terrain::Flat(70),
|
|
ticks: 20 * 60 * 10,
|
|
stop_at_end: true,
|
|
ew: false,
|
|
stuck_after: 600,
|
|
}
|
|
}
|
|
pub fn unit(&mut self, kind: SamKind, x: f64, z: f64) -> &mut Unit {
|
|
self.units.push(Unit { kind, pos: DVec3::new(x, 70.0, z), heading: 0.0, empty: false });
|
|
self.units.last_mut().unwrap()
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct Report {
|
|
pub name: String,
|
|
pub seed: u64,
|
|
pub ticks_run: u64,
|
|
pub units: usize,
|
|
pub launched: u32,
|
|
pub kills: u32,
|
|
pub hits: u32,
|
|
/// Missiles fired by air defence (sum of the systems' `fired`).
|
|
pub fired: u32,
|
|
pub ground_queries: u64,
|
|
/// The block cache's counters (issue #43) and the drones that struck the land (issue #42).
|
|
pub world: String,
|
|
pub crashes: u32,
|
|
/// What went wrong for the air defence, as the raid report words it.
|
|
pub failures: String,
|
|
pub ground_batches: u64,
|
|
pub tick_p50: Duration,
|
|
pub tick_p95: Duration,
|
|
pub tick_max: Duration,
|
|
pub tick_total: Duration,
|
|
/// Time spent in ticks that began with a raid being planned.
|
|
pub planning: Duration,
|
|
pub planning_ticks: u64,
|
|
pub nan_positions: u64,
|
|
/// Ids of trucks that stood on a job without progress for too long.
|
|
pub stuck_trucks: Vec<u32>,
|
|
/// Truck-ticks spent on a job or driving (shows the logistics actually ran).
|
|
pub truck_busy_ticks: u64,
|
|
pub raids_ordered: usize,
|
|
pub raids_ended: usize,
|
|
pub all_ended: bool,
|
|
/// Systems the defence lost (destroyed units at the end).
|
|
pub sams_lost: u32,
|
|
/// The most retarget route jobs waiting at once (#127).
|
|
pub retargets_max: usize,
|
|
/// The largest air section a save would have taken, in bytes (#127).
|
|
pub air_bytes: usize,
|
|
/// The aims every drone ended with, by intent: "plan:1,sead:2,react:3,replace:0".
|
|
pub intents: String,
|
|
/// The most aim switches one drone went through.
|
|
pub switches_max: u16,
|
|
}
|
|
|
|
/// The last intent every smart drone of the run was seen carrying, as `name:count`.
|
|
fn intent_counts(seen: &HashMap<u32, &'static str>) -> String {
|
|
let mut counts = std::collections::BTreeMap::new();
|
|
for name in seen.values() {
|
|
*counts.entry(*name).or_insert(0usize) += 1;
|
|
}
|
|
["plan", "sead", "react", "replace"].iter().map(|k| format!("{k}:{}", counts.get(*k).copied().unwrap_or(0))).collect::<Vec<_>>().join(",")
|
|
}
|
|
|
|
fn finite(v: DVec3) -> bool {
|
|
v.x.is_finite() && v.y.is_finite() && v.z.is_finite()
|
|
}
|
|
|
|
pub fn run(sc: &Scenario) -> Report {
|
|
let mut sim = Sim::new(sc.seed);
|
|
sim.damage = false; // explosions would change the land the height function describes
|
|
for u in &sc.units {
|
|
let id = sim.id();
|
|
// Systems stand on the land, whatever the layout says.
|
|
let pos = DVec3::new(u.pos.x, f64::from(sc.terrain.height(u.pos.x.floor() as i32, u.pos.z.floor() as i32)), u.pos.z);
|
|
let mut s = Sam::new(id, u.kind, pos, u.heading);
|
|
if u.empty {
|
|
s.empty = true;
|
|
s.missiles = 0;
|
|
}
|
|
sim.sams.push(s);
|
|
}
|
|
sim.targets = sc.objects.iter().map(|o| DVec3::new(o.x, f64::from(sc.terrain.height(o.x.floor() as i32, o.z.floor() as i32)), o.z)).collect();
|
|
sim.target_health = vec![100.0; sc.objects.len()];
|
|
if sc.ew {
|
|
sim.set_ew(true);
|
|
}
|
|
let mut ground = Ground::default();
|
|
let mut pending: Vec<(i32, i32, i32)> = Vec::new();
|
|
let mut r = Report { name: sc.name.clone(), seed: sc.seed, units: sc.units.len(), ..Default::default() };
|
|
let mut times: Vec<Duration> = Vec::with_capacity(sc.ticks as usize);
|
|
let mut ordered = vec![false; sc.raids.len()];
|
|
let mut launched_before = vec![0u32; sc.raids.len()];
|
|
let mut ended = vec![false; sc.raids.len()];
|
|
// truck id -> (last position, ticks standing while busy)
|
|
let mut standing: HashMap<u32, (DVec3, u64)> = HashMap::new();
|
|
// drone id -> the last structured intent it carried (#127).
|
|
let mut intents_seen: HashMap<u32, &'static str> = HashMap::new();
|
|
let mut out = Out::default();
|
|
for now in 1..=sc.ticks {
|
|
// Raids come in order: one is ordered once the previous one has been sent.
|
|
for (i, spec) in sc.raids.iter().enumerate() {
|
|
if !ordered[i] && now >= spec.at && !sim.planning() && (i == 0 || ended[i - 1]) {
|
|
let order = RaidOrder { kinds: spec.kinds.clone(), approach: spec.approach, dist: spec.dist, aim: spec.aim };
|
|
launched_before[i] = sim.launched;
|
|
let objects = sim.targets.clone();
|
|
sim.order_raid(&order, &objects, &mut out);
|
|
ordered[i] = true;
|
|
}
|
|
}
|
|
ground.answer(std::mem::take(&mut pending), now);
|
|
let planning = sim.planning();
|
|
out = Out::default();
|
|
let t = Instant::now();
|
|
sim.step(&mut ground, None, &mut out);
|
|
let wanted = ground.take_wanted();
|
|
let sections = ground.world.take_wanted(now);
|
|
ground.world.serve(&sc.terrain, sections, now);
|
|
let dt = t.elapsed();
|
|
times.push(dt);
|
|
if planning {
|
|
r.planning += dt;
|
|
r.planning_ticks += 1;
|
|
}
|
|
if !wanted.is_empty() {
|
|
r.ground_batches += 1;
|
|
r.ground_queries += wanted.len() as u64;
|
|
pending = wanted.into_iter().map(|(x, z)| (x, z, sc.terrain.height(x, z))).collect();
|
|
}
|
|
r.ticks_run = now;
|
|
r.retargets_max = r.retargets_max.max(sim.retargets_len());
|
|
r.switches_max = sim.drones.iter().chain(sim.queue.iter().map(|(_, d)| d)).map(|d| d.aim_switches()).max().unwrap_or(0).max(r.switches_max);
|
|
for d in sim.drones.iter().chain(sim.queue.iter().map(|(_, d)| d)) {
|
|
if d.alive() && d.smart() {
|
|
intents_seen.insert(d.id, d.intent().name());
|
|
}
|
|
}
|
|
// The air section a save would take, sampled when the sky is fullest (writing it every tick
|
|
// would distort the timings the bench measures).
|
|
if sim.drones.len() > r.air_bytes {
|
|
r.air_bytes = sim.air_text().map_or(0, |t| t.len());
|
|
}
|
|
// NaN check on everything with a position.
|
|
let bad = sim.drones.iter().filter(|d| !finite(d.pos) || !finite(d.vel)).count()
|
|
+ sim.missiles.iter().filter(|m| !finite(m.pos)).count()
|
|
+ sim.sams.iter().filter(|s| !finite(s.pos)).count()
|
|
+ sim.blasts.iter().filter(|b| !finite(b.at)).count()
|
|
+ out.models.iter().filter(|m| !finite(m.at)).count();
|
|
r.nan_positions += bad as u64;
|
|
// Trucks with a job or on the move, standing still.
|
|
for s in sim.sams.iter().filter(|s| s.kind == SamKind::Tzm && s.alive()) {
|
|
let busy = s.moving() || s.job().is_some();
|
|
r.truck_busy_ticks += u64::from(busy);
|
|
let e = standing.entry(s.id).or_insert((s.pos, 0));
|
|
if !busy || e.0.distance(s.pos) > 0.05 {
|
|
*e = (s.pos, 0);
|
|
} else {
|
|
e.1 += 1;
|
|
if e.1 == sc.stuck_after && !r.stuck_trucks.contains(&s.id) {
|
|
r.stuck_trucks.push(s.id);
|
|
}
|
|
}
|
|
}
|
|
// A raid has ended when it was ordered, planned, flown and nothing is left in the air.
|
|
let quiet = !sim.planning() && sim.queue.is_empty() && !sim.drones.iter().any(|d| d.alive()) && sim.missiles.is_empty();
|
|
for i in 0..sc.raids.len() {
|
|
if ordered[i] && !ended[i] && quiet && sim.launched > launched_before[i] {
|
|
ended[i] = true;
|
|
}
|
|
}
|
|
if sc.stop_at_end && ended.iter().all(|e| *e) && !sc.raids.is_empty() {
|
|
break;
|
|
}
|
|
}
|
|
r.launched = sim.launched;
|
|
r.sams_lost = sim.sams.iter().filter(|s| !s.alive()).count() as u32;
|
|
r.kills = sim.kills;
|
|
r.hits = sim.hits;
|
|
r.fired = sim.sams.iter().map(|s| s.fired).sum();
|
|
r.raids_ordered = ordered.iter().filter(|o| **o).count();
|
|
r.world = world_view::text(&ground.world);
|
|
r.crashes = sim.crashes;
|
|
r.failures = sim.tally.text();
|
|
r.raids_ended = ended.iter().filter(|o| **o).count();
|
|
r.all_ended = r.raids_ended == sc.raids.len();
|
|
r.intents = intent_counts(&intents_seen);
|
|
r.tick_total = times.iter().sum();
|
|
times.sort();
|
|
if !times.is_empty() {
|
|
let at = |q: f64| times[((times.len() - 1) as f64 * q).round() as usize];
|
|
r.tick_p50 = at(0.5);
|
|
r.tick_p95 = at(0.95);
|
|
r.tick_max = *times.last().unwrap();
|
|
}
|
|
r
|
|
}
|
|
|
|
fn ms(d: Duration) -> f64 {
|
|
d.as_secs_f64() * 1000.0
|
|
}
|
|
|
|
impl Report {
|
|
/// Problems that fail a scenario: empty when it is healthy.
|
|
pub fn problems(&self) -> Vec<String> {
|
|
let mut p = Vec::new();
|
|
if self.nan_positions > 0 {
|
|
p.push(format!("{} non-finite positions", self.nan_positions));
|
|
}
|
|
if !self.stuck_trucks.is_empty() {
|
|
p.push(format!("stuck trucks: {:?}", self.stuck_trucks));
|
|
}
|
|
if !self.all_ended {
|
|
p.push(format!("{} of {} raids ended in {} ticks", self.raids_ended, self.raids_ended.max(self.raids_ordered), self.ticks_run));
|
|
}
|
|
p
|
|
}
|
|
pub fn text(&self) -> String {
|
|
format!(
|
|
"scenario {name} (seed {seed}): {units} units, {ticks} ticks ({secs:.0} s of game time)\n\
|
|
raids: {ro} ordered, {re} ended\n\
|
|
launched {l}, shot down {k}, got through {h}, air-defence missiles fired {f}\n\
|
|
tick time ms: p50 {p50:.3} p95 {p95:.3} max {max:.3} total {tot:.0}\n\
|
|
planning: {pl:.1} ms over {pt} ticks\n\
|
|
ground queries: {gq} in {gb} batches\n\
|
|
non-finite positions: {nan}\n\
|
|
stuck trucks: {stuck:?} (busy truck-ticks {busy})\n\
|
|
crashes into the land: {crashes}; {world}\n\
|
|
air-defence failures: {failures}\n",
|
|
name = self.name,
|
|
seed = self.seed,
|
|
units = self.units,
|
|
ticks = self.ticks_run,
|
|
secs = self.ticks_run as f64 / 20.0,
|
|
ro = self.raids_ordered,
|
|
re = self.raids_ended,
|
|
l = self.launched,
|
|
k = self.kills,
|
|
h = self.hits,
|
|
f = self.fired,
|
|
p50 = ms(self.tick_p50),
|
|
p95 = ms(self.tick_p95),
|
|
max = ms(self.tick_max),
|
|
tot = ms(self.tick_total),
|
|
pl = ms(self.planning),
|
|
pt = self.planning_ticks,
|
|
gq = self.ground_queries,
|
|
gb = self.ground_batches,
|
|
nan = self.nan_positions,
|
|
stuck = self.stuck_trucks,
|
|
busy = self.truck_busy_ticks,
|
|
crashes = self.crashes,
|
|
world = self.world,
|
|
failures = if self.failures.is_empty() { "none" } else { &self.failures },
|
|
)
|
|
}
|
|
pub fn json(&self) -> String {
|
|
format!(
|
|
"{{\"scenario\":{:?},\"seed\":{},\"units\":{},\"ticks\":{},\"raids_ordered\":{},\"raids_ended\":{},\
|
|
\"launched\":{},\"kills\":{},\"hits\":{},\"fired\":{},\
|
|
\"tick_ms\":{{\"p50\":{:.4},\"p95\":{:.4},\"max\":{:.4},\"total\":{:.2}}},\
|
|
\"planning_ms\":{:.2},\"planning_ticks\":{},\"ground_queries\":{},\"ground_batches\":{},\
|
|
\"nan_positions\":{},\"stuck_trucks\":{:?},\"truck_busy_ticks\":{}}}",
|
|
self.name,
|
|
self.seed,
|
|
self.units,
|
|
self.ticks_run,
|
|
self.raids_ordered,
|
|
self.raids_ended,
|
|
self.launched,
|
|
self.kills,
|
|
self.hits,
|
|
self.fired,
|
|
ms(self.tick_p50),
|
|
ms(self.tick_p95),
|
|
ms(self.tick_max),
|
|
ms(self.tick_total),
|
|
ms(self.planning),
|
|
self.planning_ticks,
|
|
self.ground_queries,
|
|
self.ground_batches,
|
|
self.nan_positions,
|
|
self.stuck_trucks,
|
|
self.truck_busy_ticks,
|
|
)
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------ ready-made scenarios
|
|
|
|
fn ring(sc: &mut Scenario, kinds: &[SamKind], count: usize, r0: f64, r1: f64) {
|
|
for i in 0..count {
|
|
let a = i as f64 * 2.399_963; // golden angle: an even spread without randomness
|
|
let r = r0 + (r1 - r0) * (i as f64 / count.max(1) as f64);
|
|
let kind = kinds[i % kinds.len()];
|
|
sc.unit(kind, a.sin() * r, a.cos() * r).heading = a;
|
|
}
|
|
}
|
|
|
|
/// A big smart raid on 61 systems.
|
|
pub fn big_smart() -> Scenario {
|
|
let mut sc = Scenario::new("big-smart");
|
|
sc.terrain = Terrain::Hills { base: 70, amp: 14.0, period: 90.0 };
|
|
for (x, z) in [(0.0, 0.0), (120.0, 80.0), (-150.0, -60.0)] {
|
|
sc.objects.push(DVec3::new(x, 70.0, z));
|
|
}
|
|
ring(&mut sc, &[SamKind::Radar], 6, 150.0, 500.0);
|
|
ring(&mut sc, &[SamKind::Ew], 2, 100.0, 300.0);
|
|
ring(&mut sc, &SamKind::ARMED, 53, 60.0, 450.0);
|
|
assert_eq!(sc.units.len(), 61);
|
|
sc.raids.push(RaidSpec {
|
|
kinds: vec![
|
|
(DroneKind::Gerbera, 8),
|
|
(DroneKind::Shahed, 12),
|
|
(DroneKind::Geran3, 4),
|
|
(DroneKind::Lancet, 4),
|
|
(DroneKind::Kh101, 4),
|
|
(DroneKind::Kalibr, 4),
|
|
(DroneKind::Iskander, 2),
|
|
],
|
|
approach: Approach::AllSides,
|
|
aim: Aim::Smart,
|
|
dist: 500.0,
|
|
at: 1,
|
|
});
|
|
sc.ticks = 20 * 60 * 8;
|
|
sc
|
|
}
|
|
|
|
/// Trucks and a depot supplying systems that start with empty magazines, under a raid.
|
|
pub fn logistics() -> Scenario {
|
|
let mut sc = Scenario::new("logistics");
|
|
sc.unit(SamKind::Radar, 0.0, -40.0);
|
|
sc.unit(SamKind::Depot, 300.0, 300.0);
|
|
for (x, z) in [(310.0, 320.0), (290.0, 330.0)] {
|
|
sc.unit(SamKind::Tzm, x, z);
|
|
}
|
|
sc.unit(SamKind::Tzm, 280.0, 280.0);
|
|
for (i, kind) in [SamKind::Patriot, SamKind::Tor, SamKind::Buk, SamKind::Nasams, SamKind::Pantsir, SamKind::S400].into_iter().enumerate() {
|
|
let a = i as f64 * 1.05;
|
|
let u = sc.unit(kind, a.sin() * 120.0, a.cos() * 120.0);
|
|
// Every other system starts out of missiles: the trucks have work from the first second.
|
|
u.empty = i % 2 == 0;
|
|
}
|
|
sc.raids.push(RaidSpec {
|
|
kinds: vec![(DroneKind::Shahed, 16), (DroneKind::Gerbera, 8), (DroneKind::Kh101, 3)],
|
|
approach: Approach::TwoSectors,
|
|
aim: Aim::Objects,
|
|
dist: 400.0,
|
|
at: 1,
|
|
});
|
|
sc.ticks = 20 * 60 * 6;
|
|
sc
|
|
}
|
|
|
|
/// EW stations on and a smart enemy that adapts over three raids.
|
|
pub fn ew_adaptive() -> Scenario {
|
|
let mut sc = Scenario::new("ew-adaptive");
|
|
sc.ew = true;
|
|
sc.unit(SamKind::Radar, 0.0, 0.0);
|
|
sc.unit(SamKind::Radar, 200.0, -200.0);
|
|
sc.unit(SamKind::Ew, 80.0, 0.0);
|
|
sc.unit(SamKind::Ew, -80.0, 60.0);
|
|
for (i, kind) in [SamKind::Pantsir, SamKind::Gepard, SamKind::Tor, SamKind::Patriot, SamKind::Buk, SamKind::Gepard].into_iter().enumerate() {
|
|
let a = i as f64 * 1.05;
|
|
sc.unit(kind, a.sin() * 150.0, a.cos() * 150.0);
|
|
}
|
|
for at in [1, 1, 1] {
|
|
sc.raids.push(RaidSpec {
|
|
kinds: vec![(DroneKind::Gerbera, 6), (DroneKind::Shahed, 10), (DroneKind::Kh101, 4), (DroneKind::Kalibr, 3)],
|
|
approach: Approach::AllSides,
|
|
aim: Aim::Smart,
|
|
dist: 450.0,
|
|
at,
|
|
});
|
|
}
|
|
sc.ticks = 20 * 60 * 12;
|
|
sc
|
|
}
|
|
|
|
pub fn preset(name: &str) -> Option<Scenario> {
|
|
match name {
|
|
"big-smart" => Some(big_smart()),
|
|
"logistics" => Some(logistics()),
|
|
"ew-adaptive" => Some(ew_adaptive()),
|
|
_ => None,
|
|
}
|
|
}
|
|
pub const PRESETS: [&str; 3] = ["big-smart", "logistics", "ew-adaptive"];
|