245aceb434
A smart raid may send a small, bounded flight of unarmed Gerbera aircraft ahead of its strike. They fly physically through zones round the marked objectives (and revisit a doubtful mark when nothing is unchecked), look at units inside a zone, and radio home an area, a public category, the channel, age and quality only after a delay and only while the aircraft is alive. A sortie lost before its report sends nothing; marks already delivered stay, and the picture remembers them across raids. The planner now reads recon marks as well as disclosure contacts. A mark carries a synthetic id, an area, a category and a radar role only once a second independent look refines it -- never a real id, SamKind, exact point, health, magazine or link. Aims are chosen by observed role, freshness and quality; a fresh modest mark can outrank a stale doubtful big one, and a hidden unit is in neither list. In-flight recon aims keep their old area: hidden moves, re-roles and damage do not rewrite a mark. Bounded assignments, the route-job queue, the original wave objectives and the no-eternal-pause rule are preserved. Recon aircraft take ids from their own range, do not spend the strike's combat RNG and are not part of the strike's replay. Save/load keeps marks, sorties, pending reports and checked zones. No new models, textures or weapons. Co-Authored-By: Kimi Code <noreply@moonshot.ai>
1220 lines
64 KiB
Rust
1220 lines
64 KiB
Rust
//! The enemy's air state in the autosave (#127): the raid's drones, the launch queue, the retarget
|
|
//! jobs still waiting, the picture they were chosen from and the land they were planned over.
|
|
//!
|
|
//! A route job alone is not durable. Its drone may still be on the ground or already flying, and its
|
|
//! aim is only meaningful with the picture the adaptive tick chose it from and the relief snapshot of
|
|
//! that knowledge version. So the save writes the whole air state that a pending job depends on, and
|
|
//! the load rebuilds it: drones, launch queue, jobs (with their id, aim, unit, version, priority and
|
|
//! intent), the contacts, and each relief version a pending job still uses. Nothing of the live
|
|
//! picture is mixed into a replay: a recording keeps trajectories, and this section is written and
|
|
//! read for the live simulation only.
|
|
//!
|
|
//! Reconnaissance flights and the partial picture they radioed home are part of the same
|
|
//! section (#135): their marks (an area, a category and an age, never a unit's truth), the
|
|
//! sorties still out with their pending reports, and the zones already checked. A save keeps
|
|
//! that memory across raids, and a restored flight finishes the same way.
|
|
//!
|
|
//! The format is its own versioned section of `state_text` (`air 1 ...`). A save without the section
|
|
//! (every save made before #127) loads exactly as before: the layout, and an empty sky. Every value is
|
|
//! checked before anything is restored, like [`layout`](crate::layout): a bad line refuses the whole
|
|
//! save and names the line and the field. Everything is bounded — drones, queued launches, jobs,
|
|
//! contacts, route points and relief cells — so a saved air state can never grow the file without limit.
|
|
use super::*;
|
|
use std::collections::{BTreeMap, HashMap};
|
|
|
|
/// The section's format version. A different one is refused rather than half-read.
|
|
const VERSION: u32 = 1;
|
|
/// Drones in the air a save may hold. A raid is normally tens of drones; this bound keeps the
|
|
/// section far inside the host's per-write storage budget even if a scenario makes thousands.
|
|
const MAX_DRONES: usize = 512;
|
|
/// Bytes the section may take before further drones are left out (the host allows 1 MiB a write;
|
|
/// the layout and the headroom of the rest of the state stay clear of it).
|
|
const MAX_BYTES: usize = 900_000;
|
|
/// Bytes the recon block (marks, checked zones, sorties) may take. The drone loop keeps this much
|
|
/// room free, so the recon memory never pushes the section past `MAX_BYTES` (#135).
|
|
const MAX_RECON_BYTES: usize = 150_000;
|
|
/// Route points one drone may have in a save.
|
|
const MAX_ROUTE: usize = 512;
|
|
/// Contacts (the picture, and a job's picture rebuilt from it) a save may hold.
|
|
const MAX_CONTACTS: usize = 4096;
|
|
/// Relief versions a save may hold, and the cells of each.
|
|
const MAX_RELIEFS: usize = 8;
|
|
const MAX_CELLS: usize = 40_000;
|
|
/// Recon marks, checked zones and sorties a save may hold (#135).
|
|
const MAX_RECON_MARKS: usize = recon::MAX_MARKS;
|
|
const MAX_RECON_CHECKED: usize = recon::MAX_CHECKED;
|
|
const MAX_RECON_SORTIES: usize = recon::SORTIES_MAX * 2;
|
|
|
|
/// What the air section of a save holds, checked as a whole before the scene is touched.
|
|
pub struct AirSave {
|
|
tick: u64,
|
|
job_next: u32,
|
|
kills: [u32; ew::SECTORS],
|
|
hits: [u32; ew::SECTORS],
|
|
contacts: Vec<ew::Contact>,
|
|
drones: Vec<Drone>,
|
|
queue: Vec<(u64, Drone)>,
|
|
jobs: Vec<JobRec>,
|
|
/// The land new retarget jobs take as their version.
|
|
known_relief: Option<std::sync::Arc<ew::KnownRelief>>,
|
|
/// The enemy's recon flights and the partial picture they radioed home (#135).
|
|
recon: recon::Recon,
|
|
}
|
|
|
|
pub(crate) struct JobRec {
|
|
id: u32,
|
|
drone: u32,
|
|
aim: DVec3,
|
|
unit: u32,
|
|
version: u64,
|
|
intent: ew::Intent,
|
|
relief: Option<std::sync::Arc<ew::KnownRelief>>,
|
|
}
|
|
|
|
/// A saved line's words, with the line number for the refusal.
|
|
struct Line<'a> {
|
|
n: usize,
|
|
word: &'a str,
|
|
w: Vec<&'a str>,
|
|
}
|
|
|
|
impl Line<'_> {
|
|
fn bad(&self, field: &str, why: &str) -> String {
|
|
format!("строка {}: «{}», поле {field}: {why}", self.n, self.word)
|
|
}
|
|
fn word(&self, i: usize, field: &str) -> Result<&str, String> {
|
|
self.w.get(i).copied().ok_or_else(|| self.bad(field, "строка оборвана"))
|
|
}
|
|
fn count(&self, i: usize, field: &str, max: usize) -> Result<usize, String> {
|
|
let v = self.word(i, field)?;
|
|
let n: usize = v.parse().map_err(|_| self.bad(field, &format!("«{v}» не целое число")))?;
|
|
if n > max {
|
|
return Err(self.bad(field, &format!("{n} больше {max}")));
|
|
}
|
|
Ok(n)
|
|
}
|
|
fn int(&self, i: usize, field: &str, lo: i64, hi: i64) -> Result<i64, String> {
|
|
let v = self.word(i, field)?;
|
|
let n: i64 = v.parse().map_err(|_| self.bad(field, &format!("«{v}» не целое число")))?;
|
|
if n < lo || n > hi {
|
|
return Err(self.bad(field, &format!("{n} вне допустимого {lo}..{hi}")));
|
|
}
|
|
Ok(n)
|
|
}
|
|
fn flag(&self, i: usize, field: &str) -> Result<bool, String> {
|
|
match self.word(i, field)? {
|
|
"true" => Ok(true),
|
|
"false" => Ok(false),
|
|
v => Err(self.bad(field, &format!("«{v}»: нужно true или false"))),
|
|
}
|
|
}
|
|
fn num(&self, i: usize, field: &str) -> Result<f64, String> {
|
|
let v = self.word(i, field)?;
|
|
let x: f64 = v.parse().map_err(|_| self.bad(field, &format!("«{v}» не число")))?;
|
|
if !x.is_finite() || x.abs() > 3.0e7 {
|
|
return Err(self.bad(field, &format!("«{v}» не конечное допустимое число")));
|
|
}
|
|
Ok(x)
|
|
}
|
|
fn opt_tick(&self, i: usize, field: &str) -> Result<Option<u64>, String> {
|
|
if self.word(i, field)? == "-" {
|
|
return Ok(None);
|
|
}
|
|
Ok(Some(self.int(i, field, 0, 1 << 40)? as u64))
|
|
}
|
|
}
|
|
|
|
/// `x` as the save writes coordinates: centimetres are plenty for a flight, and keep the file small.
|
|
fn coord(x: f64) -> String {
|
|
format!("{x:.2}")
|
|
}
|
|
|
|
/// One run of the relief as the save writes it: `u<run>` for unknown land, `<height>x<run>` for known.
|
|
fn run_token(height: Option<i32>, run: usize) -> String {
|
|
height.map_or_else(|| format!("u{run}"), |h| format!("{h}x{run}"))
|
|
}
|
|
|
|
fn tick(x: Option<u64>) -> String {
|
|
x.map_or_else(|| "-".into(), |v| v.to_string())
|
|
}
|
|
|
|
fn intent_of(key: &str) -> Option<ew::Intent> {
|
|
ew::Intent::from_key(key)
|
|
}
|
|
|
|
fn flight_key(f: Flight) -> &'static str {
|
|
match f {
|
|
Flight::Cruise => "cruise",
|
|
Flight::Dive => "dive",
|
|
Flight::Ballistic => "ballistic",
|
|
Flight::Falling => "falling",
|
|
}
|
|
}
|
|
|
|
fn flight_of(key: &str) -> Option<Flight> {
|
|
[Flight::Cruise, Flight::Dive, Flight::Ballistic, Flight::Falling].into_iter().find(|f| flight_key(*f) == key)
|
|
}
|
|
|
|
impl Drone {
|
|
/// The drone as one line of the save: its flight, its aim and intent, and its route.
|
|
fn air_line(&self, word: &str, lead: &str) -> String {
|
|
let mut route = String::from("-");
|
|
if !self.route.is_empty() {
|
|
route = self.route.len().to_string();
|
|
for p in &self.route {
|
|
route += &format!(" {} {} {}", coord(p.x), coord(p.y), coord(p.z));
|
|
}
|
|
}
|
|
format!(
|
|
"{word} {lead}{id} {kind} {} {} {} {} {} {} {} {} {} {flight} {intent} {unit} {since} {switches} {conf} {} {} {} {age} {engaged} {sector} {low} {jammed} {smart} {hold} {} {} {} {route}",
|
|
coord(self.pos.x),
|
|
coord(self.pos.y),
|
|
coord(self.pos.z),
|
|
coord(self.vel.x),
|
|
coord(self.vel.y),
|
|
coord(self.vel.z),
|
|
coord(self.target.x),
|
|
coord(self.target.y),
|
|
coord(self.target.z),
|
|
coord(self.err.x),
|
|
coord(self.err.y),
|
|
coord(self.err.z),
|
|
if self.pace.best.is_finite() { coord(self.pace.best) } else { "-".into() },
|
|
self.pace.at,
|
|
if self.pace.route == usize::MAX { "-".to_string() } else { self.pace.route.to_string() },
|
|
kind = self.kind.spec().key,
|
|
flight = flight_key(self.flight),
|
|
intent = self.intent.key(),
|
|
unit = self.aim.unit,
|
|
since = self.aim.since,
|
|
switches = self.aim.switches,
|
|
conf = self.aim.confidence.map_or("-", |c| c.name()),
|
|
age = self.age,
|
|
engaged = self.engaged,
|
|
sector = self.sector,
|
|
low = self.low,
|
|
jammed = self.jammed,
|
|
smart = self.smart,
|
|
hold = self.hold,
|
|
id = self.id,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Sim {
|
|
/// A cheap shape of the air state for the autosave's dirty check: a launch, a loss, a new or
|
|
/// finished job changes it, a drone's own progress through the sky does not. A save takes the
|
|
/// air state at those moments, not on every tick of a flight (#127).
|
|
pub fn air_mark(&self) -> u64 {
|
|
let drones = self.drones.iter().filter(|d| d.alive()).count() as u64;
|
|
drones
|
|
^ (self.queue.len() as u64) << 12
|
|
^ (self.retargets.len() as u64) << 24
|
|
^ (self.intel.contacts().len() as u64) << 36
|
|
^ (self.job_next as u64) << 48
|
|
^ self.recon.mark().rotate_left(12)
|
|
}
|
|
|
|
/// The air section of the state text: `None` when there is nothing to keep (an empty sky and no
|
|
/// picture), so a save of a quiet world does not grow. Every pending job's drone is written with
|
|
/// it, together with the picture and the relief versions the job still plans over (#127).
|
|
pub fn air_text(&self) -> Option<String> {
|
|
// What the parser accepts is what is written: a save this build writes always reads back.
|
|
let contacts: Vec<ew::Contact> = self.intel.contacts().values().copied().take(MAX_CONTACTS).collect();
|
|
let drones: Vec<&Drone> = self.drones.iter().filter(|d| d.alive()).take(MAX_DRONES).collect();
|
|
let queued: Vec<&(u64, Drone)> = self.queue.iter().take(MAX_DRONES).collect();
|
|
// The relief versions still referenced: the global one and every pending job's. They are
|
|
// resolved before the drone lines so the head is fixed while the body's size is measured.
|
|
let mut reliefs: Vec<std::sync::Arc<ew::KnownRelief>> = Vec::new();
|
|
let token_of = |r: &std::sync::Arc<ew::KnownRelief>, reliefs: &mut Vec<std::sync::Arc<ew::KnownRelief>>| -> Option<usize> {
|
|
let at = std::sync::Arc::as_ptr(r) as usize;
|
|
if let Some(i) = reliefs.iter().position(|x| std::sync::Arc::as_ptr(x) as usize == at) {
|
|
return Some(i);
|
|
}
|
|
if reliefs.len() >= MAX_RELIEFS {
|
|
return None;
|
|
}
|
|
reliefs.push(std::sync::Arc::clone(r));
|
|
Some(reliefs.len() - 1)
|
|
};
|
|
let global = self.known_relief.as_ref().and_then(|r| token_of(r, &mut reliefs));
|
|
let job_relief: Vec<Option<usize>> = self.retargets.iter().map(|j| j.relief.as_ref().and_then(|r| token_of(r, &mut reliefs))).collect();
|
|
let (kills, hits) = self.intel.sectors();
|
|
// The head, with the counts filled in later; its length is what the body is measured against.
|
|
let mut head = format!("air {VERSION} {} {} 0 0 0 {} {}\n", self.tick, self.job_next, contacts.len(), reliefs.len());
|
|
head += "airintel";
|
|
for v in kills.iter().chain(hits.iter()) {
|
|
head += &format!(" {v}");
|
|
}
|
|
head += "\n";
|
|
head += &format!("airglobal {}\n", global.map_or_else(|| "-".into(), |t| t.to_string()));
|
|
for (i, r) in reliefs.iter().enumerate() {
|
|
let g = r.grid();
|
|
let mut line = format!("airrelief {i} {} {} {} {} ", coord(g.min.x), coord(g.min.z), coord(g.cell), g.size);
|
|
let mut run: Option<(Option<i32>, usize)> = None;
|
|
for h in r.heights() {
|
|
let key = h.is_finite().then(|| h.round() as i32);
|
|
match run {
|
|
Some((k, n)) if k == key => run = Some((k, n + 1)),
|
|
Some((k, n)) => {
|
|
line += &format!("{} ", run_token(k, n));
|
|
run = Some((key, 1));
|
|
}
|
|
None => run = Some((key, 1)),
|
|
}
|
|
}
|
|
if let Some((k, n)) = run {
|
|
line += &run_token(k, n);
|
|
}
|
|
head += &line;
|
|
head += "\n";
|
|
}
|
|
for c in &contacts {
|
|
head += &format!(
|
|
"aircontact {} {} {} {} {} {} {} {} {} {}\n",
|
|
c.id,
|
|
c.kind.spec().key,
|
|
coord(c.at.x),
|
|
coord(c.at.y),
|
|
coord(c.at.z),
|
|
c.tick,
|
|
c.seen.name(),
|
|
tick(c.emission),
|
|
tick(c.destroyed),
|
|
c.launches
|
|
);
|
|
}
|
|
// The bodies go in while the section stays inside its byte bound; a drone left out takes its
|
|
// job with it (a job whose drone is not saved could never be restored).
|
|
let mut body = String::new();
|
|
let mut saved: std::collections::HashSet<u32> = std::collections::HashSet::new();
|
|
let fits = |head: &str, body: &str, line: &str| head.len() + 32 + body.len() + line.len() + MAX_RECON_BYTES <= MAX_BYTES;
|
|
let mut drone_count = 0usize;
|
|
for d in &drones {
|
|
let line = d.air_line("airdrone", "");
|
|
if !fits(&head, &body, &line) {
|
|
break;
|
|
}
|
|
body += &line;
|
|
body += "\n";
|
|
saved.insert(d.id);
|
|
drone_count += 1;
|
|
}
|
|
let mut queued_count = 0usize;
|
|
for (at, d) in &queued {
|
|
let line = d.air_line("airqueue", &format!("{at} "));
|
|
if !fits(&head, &body, &line) {
|
|
break;
|
|
}
|
|
body += &line;
|
|
body += "\n";
|
|
saved.insert(d.id);
|
|
queued_count += 1;
|
|
}
|
|
// A job's unit may be an exact contact or a recon mark's synthetic id (#135).
|
|
let units: std::collections::HashSet<u32> = contacts.iter().map(|c| c.id).chain(self.recon.marks.keys().copied()).collect();
|
|
let jobs: Vec<(&ew::RouteJob, Option<usize>)> = self
|
|
.retargets
|
|
.iter()
|
|
.zip(job_relief)
|
|
.filter(|(j, _)| saved.contains(&j.drone) && (j.unit == 0 || units.contains(&j.unit)))
|
|
.collect();
|
|
if drone_count == 0 && queued_count == 0 && jobs.is_empty() && contacts.is_empty() && self.recon.is_empty() {
|
|
return None;
|
|
}
|
|
let head = head.replacen(
|
|
&format!("air {VERSION} {} {} 0 0 0 ", self.tick, self.job_next),
|
|
&format!("air {VERSION} {} {} {drone_count} {queued_count} {} ", self.tick, self.job_next, jobs.len()),
|
|
1,
|
|
);
|
|
let mut text = head;
|
|
text += &body;
|
|
for (job, relief) in jobs {
|
|
text += &format!(
|
|
"airjob {} {} {} {} {} {} {} {} {} {}\n",
|
|
job.id,
|
|
job.drone,
|
|
coord(job.aim.x),
|
|
coord(job.aim.y),
|
|
coord(job.aim.z),
|
|
job.unit,
|
|
job.version,
|
|
job.priority(),
|
|
job.intent.key(),
|
|
relief.map_or_else(|| "-".into(), |t| t.to_string())
|
|
);
|
|
}
|
|
// Recon: the marks are memory (survive a new raid), the sorties are the aircraft still
|
|
// out, and the zones already reported empty. Everything is bounded, and each line is
|
|
// added only while the block stays inside its budget (#135).
|
|
if !self.recon.is_empty() {
|
|
let room = MAX_RECON_BYTES.min(MAX_BYTES.saturating_sub(text.len() + 96));
|
|
let mut recon_body = String::new();
|
|
let mut add = |line: &str| -> bool {
|
|
if recon_body.len() + line.len() > room {
|
|
return false;
|
|
}
|
|
recon_body.push_str(line);
|
|
true
|
|
};
|
|
let mut marks = 0usize;
|
|
for m in self.recon.marks.values().take(MAX_RECON_MARKS) {
|
|
let truth = self.recon.truth.get(&m.id).copied().unwrap_or(0);
|
|
let line = format!(
|
|
"airreconmark {} {} {} {} {} {} {} {} {} {} {} {} {}\n",
|
|
m.id,
|
|
truth,
|
|
coord(m.area.x),
|
|
coord(m.area.y),
|
|
coord(m.area.z),
|
|
coord(m.radius),
|
|
m.category.name(),
|
|
m.role.map_or_else(|| "-".to_string(), |r| r.key().to_string()),
|
|
m.source.name(),
|
|
m.quality.name(),
|
|
m.observed,
|
|
m.reported,
|
|
m.looks,
|
|
);
|
|
if !add(&line) {
|
|
break;
|
|
}
|
|
marks += 1;
|
|
}
|
|
let mut checked = 0usize;
|
|
for ((i, j), t) in self.recon.checked.iter().take(MAX_RECON_CHECKED) {
|
|
if !add(&format!("airreconchecked {i} {j} {t}\n")) {
|
|
break;
|
|
}
|
|
checked += 1;
|
|
}
|
|
let mut sorties = 0usize;
|
|
for s in self.recon.sorties.iter().filter(|s| saved.contains(&s.drone)).take(MAX_RECON_SORTIES) {
|
|
// A sortie is written whole or not at all: its look and zone lines follow its header.
|
|
let mut body = format!(
|
|
"airrec {} {} {} {} {} {} {}\n",
|
|
s.drone,
|
|
s.launched,
|
|
s.next,
|
|
tick(s.report_at),
|
|
s.report_zone.map_or_else(|| "-".into(), |z| z.to_string()),
|
|
s.pending.len(),
|
|
s.zones.len(),
|
|
);
|
|
for l in &s.pending {
|
|
body += &format!(
|
|
"airrecobs {} {} {} {} {} {} {} {} {} {}\n",
|
|
l.truth,
|
|
coord(l.area.x),
|
|
coord(l.area.y),
|
|
coord(l.area.z),
|
|
coord(l.radius),
|
|
l.category.name(),
|
|
l.role.map_or_else(|| "-".to_string(), |r| r.key().to_string()),
|
|
l.quality.name(),
|
|
l.source.name(),
|
|
l.observed,
|
|
);
|
|
}
|
|
for z in &s.zones {
|
|
body += &format!("airreczone {} {} {} {}\n", coord(z.center.x), coord(z.center.y), coord(z.center.z), coord(z.radius));
|
|
}
|
|
if !add(&body) {
|
|
break;
|
|
}
|
|
sorties += 1;
|
|
}
|
|
text += &format!("airrecon {} {} {} {} {}\n", self.recon.next, self.recon.drone_next, marks, sorties, checked);
|
|
text += &recon_body;
|
|
}
|
|
Some(text)
|
|
}
|
|
|
|
/// Reads the air section of `text` (the lines `air_text` writes). `None` when the text has none:
|
|
/// an older save, restored with an empty sky as before. Everything is checked before it is used.
|
|
pub fn parse_air(text: &str) -> Result<Option<AirSave>, String> {
|
|
let lines: Vec<(usize, Vec<&str>)> = text
|
|
.lines()
|
|
.enumerate()
|
|
.map(|(n, raw)| (n + 1, raw.split_whitespace().collect::<Vec<_>>()))
|
|
.collect();
|
|
let heads: Vec<&(usize, Vec<&str>)> = lines.iter().filter(|(_, w)| w.first() == Some(&"air")).collect();
|
|
let Some((head_n, head)) = heads.first().copied() else {
|
|
// Lines of a section whose header is gone are a corrupt file, not an old save.
|
|
if let Some((n, w)) = lines.iter().find(|(_, w)| w.first().is_some_and(|w| w.starts_with("air"))) {
|
|
return Err(format!("строка {n}: «{}», воздушная часть без заголовка air", w[0]));
|
|
}
|
|
return Ok(None);
|
|
};
|
|
if heads.len() > 1 {
|
|
return Err(format!("строка {}: воздушная часть записана дважды", heads[1].0));
|
|
}
|
|
let l = Line { n: *head_n, word: "air", w: head.clone() };
|
|
if head.len() != 9 {
|
|
return Err(l.bad("заголовок", "нужны версия, такт, счётчики и число версий рельефа"));
|
|
}
|
|
let version = l.int(1, "версия воздушной части", 0, 1 << 30)? as u32;
|
|
if version != VERSION {
|
|
return Err(l.bad("версия воздушной части", &format!("эта сборка читает только {VERSION}")));
|
|
}
|
|
let tick = l.int(2, "такт", 0, 1 << 40)?.max(0) as u64;
|
|
let job_next = l.int(3, "номер задания", 0, 1 << 30)? as u32;
|
|
let n_drones = l.count(4, "дроны", MAX_DRONES)?;
|
|
let n_queue = l.count(5, "очередь запуска", MAX_DRONES)?;
|
|
let n_jobs = l.count(6, "задания", ew::JOBS_MAX)?;
|
|
let n_contacts = l.count(7, "контакты", MAX_CONTACTS)?;
|
|
let n_reliefs = l.count(8, "версии рельефа", MAX_RELIEFS)?;
|
|
// Every line of the section, and nothing else: a truncated or foreign line is refused.
|
|
let mut intel: Option<[u32; ew::SECTORS * 2]> = None;
|
|
let mut global: Option<usize> = None;
|
|
let mut reliefs: Vec<Option<std::sync::Arc<ew::KnownRelief>>> = vec![None; n_reliefs];
|
|
let mut contacts: BTreeMap<u32, ew::Contact> = BTreeMap::new();
|
|
let mut drones: BTreeMap<u32, Drone> = BTreeMap::new();
|
|
let mut queue: Vec<(u64, Drone)> = Vec::new();
|
|
let mut jobs: Vec<JobRec> = Vec::new();
|
|
// Recon (#135): a mark line carries the unit it is of (the observer's secret, never in
|
|
// the planner's picture); a sortie's look and zone lines follow its header.
|
|
let mut recon = recon::Recon::default();
|
|
let mut recon_head: Option<(usize, usize, usize)> = None;
|
|
let mut recon_sortie_at: Option<usize> = None;
|
|
let mut recon_expect: Vec<(usize, usize)> = Vec::new();
|
|
for (n, w) in &lines {
|
|
if w.first() == Some(&"air") {
|
|
continue;
|
|
}
|
|
let Some(&word) = w.first() else { continue };
|
|
if !word.starts_with("air") {
|
|
continue;
|
|
}
|
|
let l = Line { n: *n, word, w: w.clone() };
|
|
match word {
|
|
"airintel" => {
|
|
if w.len() != 1 + ew::SECTORS * 2 {
|
|
return Err(l.bad("счётчики секторов", &format!("нужны {} чисел", ew::SECTORS * 2)));
|
|
}
|
|
let mut v = [0u32; ew::SECTORS * 2];
|
|
for (i, slot) in v.iter_mut().enumerate() {
|
|
*slot = l.int(i + 1, "счётчики секторов", 0, 1 << 30)? as u32;
|
|
}
|
|
intel = Some(v);
|
|
}
|
|
"airglobal" => {
|
|
if w.len() != 2 {
|
|
return Err(l.bad("рельеф", "нужна одна ссылка на версию рельефа"));
|
|
}
|
|
let t = l.word(1, "рельеф")?;
|
|
if t != "-" {
|
|
let at = l.count(1, "рельеф", MAX_RELIEFS)?;
|
|
if at >= n_reliefs {
|
|
return Err(l.bad("рельеф", "ссылка на неписаную версию"));
|
|
}
|
|
global = Some(at);
|
|
}
|
|
}
|
|
"airrelief" => {
|
|
let at = l.count(1, "номер рельефа", MAX_RELIEFS)?;
|
|
if at >= n_reliefs {
|
|
return Err(l.bad("номер рельефа", "больше объявленных"));
|
|
}
|
|
let grid = raid::Grid {
|
|
min: DVec3::new(l.num(2, "рельеф X")?, 0.0, l.num(3, "рельеф Z")?),
|
|
cell: l.num(4, "размер клетки")?,
|
|
size: l.int(5, "сторона сетки", 1, 400)? as i32,
|
|
};
|
|
if grid.cell <= 0.0 {
|
|
return Err(l.bad("размер клетки", "должен быть больше нуля"));
|
|
}
|
|
let cells = (grid.size * grid.size) as usize;
|
|
if cells > MAX_CELLS {
|
|
return Err(l.bad("рельеф", &format!("{cells} клеток больше {MAX_CELLS}")));
|
|
}
|
|
let mut heights = Vec::with_capacity(cells);
|
|
for t in &w[6..] {
|
|
// `u<run>` is unknown land, `<height>x<run>` a known height repeated.
|
|
let (h, run) = if let Some(n) = t.strip_prefix('u') {
|
|
(f32::NAN, n)
|
|
} else {
|
|
let Some((head, n)) = t.split_once('x') else {
|
|
return Err(l.bad("рельеф", &format!("«{t}» не повтор высоты")));
|
|
};
|
|
let v: i32 = head.parse().map_err(|_| l.bad("рельеф", &format!("«{head}» не высота")))?;
|
|
(v as f32, n)
|
|
};
|
|
let run: usize = run.parse().map_err(|_| l.bad("рельеф", "длина повтора не число"))?;
|
|
if run == 0 || run > cells {
|
|
return Err(l.bad("рельеф", &format!("повтор {run} вне 1..{cells}")));
|
|
}
|
|
if heights.len() + run > cells {
|
|
return Err(l.bad("рельеф", "повторы длиннее сетки"));
|
|
}
|
|
heights.extend(std::iter::repeat_n(h, run));
|
|
}
|
|
if heights.len() != cells {
|
|
return Err(l.bad("рельеф", "повторы не покрывают сетку"));
|
|
}
|
|
if reliefs[at].is_some() {
|
|
return Err(l.bad("номер рельефа", "версия записана дважды"));
|
|
}
|
|
reliefs[at] = Some(std::sync::Arc::new(ew::KnownRelief::new(grid, heights)));
|
|
}
|
|
"aircontact" => {
|
|
if w.len() != 11 {
|
|
return Err(l.bad("контакт", "нужны 10 полей наблюдения"));
|
|
}
|
|
let id = l.int(1, "номер юнита", 0, 1 << 30)? as u32;
|
|
let kind = SamKind::from_key(l.word(2, "тип")?).ok_or_else(|| l.bad("тип", "неизвестный тип"))?;
|
|
let at = DVec3::new(l.num(3, "контакт X")?, l.num(4, "контакт Y")?, l.num(5, "контакт Z")?);
|
|
let seen = ew::Seen::from_key(l.word(7, "канал")?).ok_or_else(|| l.bad("канал", "launch, emission или jamming"))?;
|
|
let c = ew::Contact {
|
|
id,
|
|
kind,
|
|
at,
|
|
tick: l.int(6, "такт наблюдения", 0, tick as i64)? as u64,
|
|
seen,
|
|
emission: l.opt_tick(8, "фиксация эмиссии")?,
|
|
destroyed: l.opt_tick(9, "наблюдённое уничтожение")?,
|
|
launches: l.int(10, "наблюдённые пуски", 0, u16::MAX as i64)? as u16,
|
|
};
|
|
if contacts.insert(id, c).is_some() {
|
|
return Err(l.bad("номер юнита", "контакт записан дважды"));
|
|
}
|
|
}
|
|
"airdrone" | "airqueue" => {
|
|
let at = if word == "airqueue" { Some(l.int(1, "такт запуска", 0, 1 << 40)? as u64) } else { None };
|
|
let (d, end) = parse_drone(&l, if at.is_some() { 2 } else { 1 })?;
|
|
if w.len() != end {
|
|
return Err(l.bad("дрон", "лишние поля"));
|
|
}
|
|
if at.is_some() {
|
|
queue.push((at.unwrap(), d));
|
|
} else if drones.insert(d.id, d).is_some() {
|
|
return Err(l.bad("номер дрона", "дрон записан дважды"));
|
|
}
|
|
}
|
|
"airjob" => {
|
|
if w.len() != 11 {
|
|
return Err(l.bad("задание", "нужны 9 полей задания"));
|
|
}
|
|
let id = l.int(1, "номер задания", 0, 1 << 30)? as u32;
|
|
let drone = l.int(2, "дрон задания", 0, 1 << 30)? as u32;
|
|
let aim = DVec3::new(l.num(3, "цель X")?, l.num(4, "цель Y")?, l.num(5, "цель Z")?);
|
|
let unit = l.int(6, "юнит", 0, 1 << 30)? as u32;
|
|
let version = l.int(7, "версия знаний", 0, tick as i64)? as u64;
|
|
let priority = l.int(8, "приоритет", 0, 9)? as u8;
|
|
let intent = intent_of(l.word(9, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react или replace"))?;
|
|
if priority != intent.priority() {
|
|
return Err(l.bad("приоритет", "не совпадает с намерением"));
|
|
}
|
|
let relief = match l.word(10, "рельеф")? {
|
|
"-" => None,
|
|
t => {
|
|
let at = t.parse::<usize>().map_err(|_| l.bad("рельеф", "не номер версии"))?;
|
|
if at >= n_reliefs {
|
|
return Err(l.bad("рельеф", "ссылка на неписаную версию"));
|
|
}
|
|
reliefs[at].clone()
|
|
}
|
|
};
|
|
jobs.push(JobRec { id, drone, aim, unit, version, intent, relief });
|
|
}
|
|
"airrecon" => {
|
|
if w.len() != 6 {
|
|
return Err(l.bad("разведка", "нужны счётчики отметок и дронов, отметки, разведчики и проверенные зоны"));
|
|
}
|
|
let next = l.int(1, "счётчик отметок", 0, i64::from(recon::MARK_TOP - recon::ID_BASE - 1))? as u32;
|
|
let drone_next = l.int(2, "счётчик дронов", 0, i64::from(recon::DRONE_TOP - recon::DRONE_BASE - 1))? as u32;
|
|
let marks = l.count(3, "отметки", MAX_RECON_MARKS)?;
|
|
let sorties = l.count(4, "разведчики", MAX_RECON_SORTIES)?;
|
|
let checked = l.count(5, "проверенные зоны", MAX_RECON_CHECKED)?;
|
|
if recon_head.is_some() {
|
|
return Err(l.bad("разведка", "заголовок записан дважды"));
|
|
}
|
|
recon_head = Some((marks, sorties, checked));
|
|
recon.next = next;
|
|
recon.drone_next = drone_next;
|
|
}
|
|
"airreconmark" => {
|
|
if w.len() != 14 {
|
|
return Err(l.bad("отметка разведки", "нужны id, юнит, место, категория, источник, качество и времена"));
|
|
}
|
|
let id = l.int(1, "id отметки", 0, i64::from(u32::MAX))? as u32;
|
|
if !recon::is_mark(id) {
|
|
return Err(l.bad("id отметки", "не в диапазоне отметок"));
|
|
}
|
|
let truth = l.int(2, "юнит отметки", 0, 1 << 30)? as u32;
|
|
let area = DVec3::new(l.num(3, "отметка X")?, l.num(4, "отметка Y")?, l.num(5, "отметка Z")?);
|
|
let radius = l.num(6, "радиус отметки")?;
|
|
if radius <= 0.0 {
|
|
return Err(l.bad("радиус отметки", "должен быть больше нуля"));
|
|
}
|
|
let category = recon::Category::from_key(l.word(7, "категория")?).ok_or_else(|| l.bad("категория", "unknown, radar, launcher, gun, ew или support"))?;
|
|
let role = match l.word(8, "роль")? {
|
|
"-" => None,
|
|
key => Some(battery::RadarRole::from_key(key).ok_or_else(|| l.bad("роль", "multi, search, engagement или height"))?),
|
|
};
|
|
let source = recon::Source::from_key(l.word(9, "источник")?).ok_or_else(|| l.bad("источник", "flyby, emission, jamming или launch"))?;
|
|
let quality = recon::Quality::from_key(l.word(10, "качество")?).ok_or_else(|| l.bad("качество", "coarse или refined"))?;
|
|
let observed = l.int(11, "такт наблюдения", 0, tick as i64)? as u64;
|
|
let reported = l.int(12, "такт донесения", 0, tick as i64)? as u64;
|
|
let looks = l.int(13, "число взглядов", 0, u16::MAX as i64)? as u16;
|
|
if recon.marks.contains_key(&id) {
|
|
return Err(l.bad("id отметки", "отметка записана дважды"));
|
|
}
|
|
recon.truth.insert(id, truth);
|
|
recon.marks.insert(id, recon::Mark {
|
|
id,
|
|
area,
|
|
radius,
|
|
category,
|
|
role,
|
|
source,
|
|
observed,
|
|
reported,
|
|
quality,
|
|
looks,
|
|
});
|
|
let slot = id.saturating_sub(recon::ID_BASE);
|
|
recon.next = recon.next.max(slot);
|
|
}
|
|
"airreconchecked" => {
|
|
if w.len() != 4 {
|
|
return Err(l.bad("проверенная зона", "нужны X, Z и такт"));
|
|
}
|
|
let i = l.int(1, "зона X", -3_000_000, 3_000_000)?;
|
|
let j = l.int(2, "зона Z", -3_000_000, 3_000_000)?;
|
|
let t = l.int(3, "такт проверки", 0, tick as i64)? as u64;
|
|
recon.checked.insert((i, j), t);
|
|
}
|
|
"airrec" => {
|
|
if w.len() != 8 {
|
|
return Err(l.bad("разведчик", "нужны дрон, вылет, зона, донесение и счётчики"));
|
|
}
|
|
let drone = l.int(1, "дрон разведчика", 1, 1 << 30)? as u32;
|
|
let launched = l.int(2, "вылет", 0, tick as i64)? as u64;
|
|
let next = l.count(3, "следующая зона", 1_000_000)?;
|
|
let report_at = l.opt_tick(4, "такт донесения")?;
|
|
let report_zone = match l.word(5, "зона донесения")? {
|
|
"-" => None,
|
|
v => Some(v.parse::<usize>().map_err(|_| l.bad("зона донесения", "не номер"))?),
|
|
};
|
|
let pending = l.count(6, "ожидающие наблюдения", recon::MAX_OBSERVED)?;
|
|
let zones = l.count(7, "зоны разведчика", recon::ZONES_MAX)?;
|
|
if recon.sorties.iter().any(|s| s.drone == drone) {
|
|
return Err(l.bad("дрон разведчика", "разведчик записан дважды"));
|
|
}
|
|
recon.sorties.push(recon::Sortie {
|
|
drone,
|
|
zones: Vec::new(),
|
|
next,
|
|
launched,
|
|
report_at,
|
|
report_zone,
|
|
pending: Vec::new(),
|
|
});
|
|
recon_sortie_at = Some(recon.sorties.len() - 1);
|
|
recon_expect.push((pending, zones));
|
|
}
|
|
"airrecobs" => {
|
|
if w.len() != 11 {
|
|
return Err(l.bad("наблюдение разведки", "нужны юнит, место, категория, источник и такт"));
|
|
}
|
|
let Some(at) = recon_sortie_at else {
|
|
return Err(l.bad("наблюдение разведки", "строка без разведчика"));
|
|
};
|
|
let (want, _) = recon_expect[at];
|
|
if recon.sorties[at].pending.len() >= want {
|
|
return Err(l.bad("наблюдение разведки", "наблюдений больше объявленного"));
|
|
}
|
|
let truth = l.int(1, "юнит наблюдения", 0, 1 << 30)? as u32;
|
|
let area = DVec3::new(l.num(2, "наблюдение X")?, l.num(3, "наблюдение Y")?, l.num(4, "наблюдение Z")?);
|
|
let radius = l.num(5, "радиус наблюдения")?;
|
|
if radius <= 0.0 {
|
|
return Err(l.bad("радиус наблюдения", "должен быть больше нуля"));
|
|
}
|
|
let category = recon::Category::from_key(l.word(6, "категория")?).ok_or_else(|| l.bad("категория", "unknown, radar, launcher, gun, ew или support"))?;
|
|
let role = match l.word(7, "роль")? {
|
|
"-" => None,
|
|
key => Some(battery::RadarRole::from_key(key).ok_or_else(|| l.bad("роль", "multi, search, engagement или height"))?),
|
|
};
|
|
let quality = recon::Quality::from_key(l.word(8, "качество")?).ok_or_else(|| l.bad("качество", "coarse или refined"))?;
|
|
let source = recon::Source::from_key(l.word(9, "источник")?).ok_or_else(|| l.bad("источник", "flyby, emission, jamming или launch"))?;
|
|
let observed = l.int(10, "такт наблюдения", 0, tick as i64)? as u64;
|
|
recon.sorties[at].pending.push(recon::Look { truth, area, radius, category, role, quality, source, observed });
|
|
}
|
|
"airreczone" => {
|
|
if w.len() != 5 {
|
|
return Err(l.bad("зона разведчика", "нужны X, Y, Z и радиус"));
|
|
}
|
|
let Some(at) = recon_sortie_at else {
|
|
return Err(l.bad("зона разведчика", "строка без разведчика"));
|
|
};
|
|
let (_, want) = recon_expect[at];
|
|
if recon.sorties[at].zones.len() >= want {
|
|
return Err(l.bad("зона разведчика", "зон больше объявленного"));
|
|
}
|
|
let center = DVec3::new(l.num(1, "зона X")?, l.num(2, "зона Y")?, l.num(3, "зона Z")?);
|
|
let radius = l.num(4, "радиус зоны")?;
|
|
if radius <= 0.0 {
|
|
return Err(l.bad("радиус зоны", "должен быть больше нуля"));
|
|
}
|
|
recon.sorties[at].zones.push(recon::Zone { center, radius });
|
|
}
|
|
other => return Err(l.bad("строка", &format!("неизвестная строка воздушной части «{other}»"))),
|
|
}
|
|
}
|
|
// The counts are the file's own promise: a section cut short is refused, not half-restored.
|
|
if contacts.len() != n_contacts {
|
|
return Err(format!("воздушная часть: контактов {} вместо {n_contacts}", contacts.len()));
|
|
}
|
|
if drones.len() != n_drones {
|
|
return Err(format!("воздушная часть: дронов {} вместо {n_drones}", drones.len()));
|
|
}
|
|
if queue.len() != n_queue {
|
|
return Err(format!("воздушная часть: очередь {} вместо {n_queue}", queue.len()));
|
|
}
|
|
if jobs.len() != n_jobs {
|
|
return Err(format!("воздушная часть: заданий {} вместо {n_jobs}", jobs.len()));
|
|
}
|
|
if reliefs.iter().any(Option::is_none) {
|
|
return Err("воздушная часть: объявленная версия рельефа не записана".into());
|
|
}
|
|
let mut seen_drones: std::collections::HashSet<u32> = drones.keys().copied().collect();
|
|
for (_, d) in &queue {
|
|
if !seen_drones.insert(d.id) {
|
|
return Err("воздушная часть: дрон записан и в небе, и в очереди".into());
|
|
}
|
|
}
|
|
if let Some(g) = global && reliefs[g].is_none() {
|
|
return Err("воздушная часть: глобальный рельеф не записан".into());
|
|
}
|
|
if let Some((marks, sorties, checked)) = recon_head {
|
|
if recon.marks.len() != marks {
|
|
return Err(format!("воздушная часть: отметок разведки {} вместо {marks}", recon.marks.len()));
|
|
}
|
|
if recon.sorties.len() != sorties {
|
|
return Err(format!("воздушная часть: разведчиков {} вместо {sorties}", recon.sorties.len()));
|
|
}
|
|
if recon.checked.len() != checked {
|
|
return Err(format!("воздушная часть: проверенных зон {} вместо {checked}", recon.checked.len()));
|
|
}
|
|
} else if !recon.is_empty() {
|
|
return Err("воздушная часть: разведка без заголовка airrecon".into());
|
|
}
|
|
for (i, (pending, zones)) in recon_expect.iter().enumerate() {
|
|
if recon.sorties[i].pending.len() != *pending || recon.sorties[i].zones.len() != *zones {
|
|
return Err(format!("воздушная часть: разведчик {i} записан не полностью"));
|
|
}
|
|
if recon.sorties[i].next > recon.sorties[i].zones.len() {
|
|
return Err(format!("воздушная часть: разведчик {i} смотрит за пределами зон"));
|
|
}
|
|
if let Some(z) = recon.sorties[i].report_zone
|
|
&& z >= recon.sorties[i].zones.len()
|
|
{
|
|
return Err(format!("воздушная часть: разведчик {i} доносит из несуществующей зоны"));
|
|
}
|
|
}
|
|
let intel = intel.ok_or("воздушная часть: нет счётчиков секторов")?;
|
|
let mut kills = [0u32; ew::SECTORS];
|
|
let mut hits = [0u32; ew::SECTORS];
|
|
kills.copy_from_slice(&intel[..ew::SECTORS]);
|
|
hits.copy_from_slice(&intel[ew::SECTORS..]);
|
|
Ok(Some(AirSave {
|
|
tick,
|
|
job_next,
|
|
kills,
|
|
hits,
|
|
contacts: contacts.into_values().collect(),
|
|
drones: drones.into_values().collect(),
|
|
queue,
|
|
jobs,
|
|
known_relief: global.and_then(|g| reliefs[g].clone()),
|
|
recon,
|
|
}))
|
|
}
|
|
|
|
/// Puts a checked air section back: the drones, the launch queue, the jobs (with the picture and
|
|
/// relief of each version) and the contacts. Stale jobs are cancelled, the queue is bounded, and a
|
|
/// job whose drone, aim or unit no longer stands is dropped — a restored job is never a ghost.
|
|
/// The live air state is replaced, never merged: what the sky held before the load goes.
|
|
pub fn restore_air(&mut self, save: AirSave) -> u32 {
|
|
self.tick = save.tick;
|
|
// New jobs must not reuse an id a restored job already holds.
|
|
let highest = save.jobs.iter().map(|j| j.id).max().unwrap_or(0);
|
|
self.job_next = save.job_next.max(1).max(highest.saturating_add(1));
|
|
self.intel = ew::Intel::restore(save.contacts.clone(), save.kills, save.hits);
|
|
self.known_relief = save.known_relief;
|
|
self.drones = save.drones;
|
|
self.queue = save.queue;
|
|
self.recon = save.recon;
|
|
let alive: std::collections::HashSet<u32> = self.drones.iter().map(|d| d.id).chain(self.queue.iter().map(|(_, d)| d.id)).collect();
|
|
self.recon.retain_drones(&alive);
|
|
self.recon.expire(self.tick);
|
|
self.retargets.clear();
|
|
// A job's picture is its version's: the contacts observed no later than it, plus its own
|
|
// target (whose last saved observation stands in for one made after the version).
|
|
let mut by_version: HashMap<u64, std::sync::Arc<Vec<ew::Contact>>> = HashMap::new();
|
|
for rec in save.jobs {
|
|
let known = by_version.entry(rec.version).or_insert_with(|| {
|
|
let picture: Vec<ew::Contact> = save
|
|
.contacts
|
|
.iter()
|
|
.filter(|c| c.tick <= rec.version || c.id == rec.unit)
|
|
.copied()
|
|
.collect();
|
|
std::sync::Arc::new(picture)
|
|
});
|
|
let job = ew::RouteJob::restored(rec.id, rec.drone, rec.aim, rec.unit, rec.version, rec.intent, std::sync::Arc::clone(known), rec.relief);
|
|
self.retargets.push_back(job);
|
|
}
|
|
// Jobs the saved picture no longer stands behind, and anything past the bound, go now.
|
|
self.prune_air()
|
|
}
|
|
}
|
|
|
|
/// One drone's line (after its word and, for the queue, its launch tick). Returns the drone and the
|
|
/// number of words the body took.
|
|
fn parse_drone(l: &Line, first: usize) -> Result<(Drone, usize), String> {
|
|
let id = l.int(first, "номер дрона", 1, 1 << 30)? as u32;
|
|
let kind = DroneKind::from_key(l.word(first + 1, "тип дрона")?).ok_or_else(|| l.bad("тип дрона", "неизвестный тип"))?;
|
|
let pos = DVec3::new(l.num(first + 2, "дрон X")?, l.num(first + 3, "дрон Y")?, l.num(first + 4, "дрон Z")?);
|
|
let vel = DVec3::new(l.num(first + 5, "скорость X")?, l.num(first + 6, "скорость Y")?, l.num(first + 7, "скорость Z")?);
|
|
let target = DVec3::new(l.num(first + 8, "цель X")?, l.num(first + 9, "цель Y")?, l.num(first + 10, "цель Z")?);
|
|
let flight = flight_of(l.word(first + 11, "полёт")?).ok_or_else(|| l.bad("полёт", "cruise, dive, ballistic или falling"))?;
|
|
let intent = intent_of(l.word(first + 12, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react или replace"))?;
|
|
let unit = l.int(first + 13, "юнит намерения", 0, 1 << 30)? as u32;
|
|
let since = l.int(first + 14, "такт выбора цели", 0, 1 << 40)? as u64;
|
|
let switches = l.int(first + 15, "переключения", 0, u16::MAX as i64)? as u16;
|
|
let conf = match l.word(first + 16, "уверенность")? {
|
|
"-" => None,
|
|
key => Some(ew::Confidence::from_key(key).ok_or_else(|| l.bad("уверенность", "doubtful, probable или confirmed"))?),
|
|
};
|
|
let err = DVec3::new(l.num(first + 17, "ошибка X")?, l.num(first + 18, "ошибка Y")?, l.num(first + 19, "ошибка Z")?);
|
|
let age = l.int(first + 20, "возраст", 0, 1 << 30)? as u32;
|
|
let engaged = l.int(first + 21, "обстрелян", 0, 1 << 20)? as u32;
|
|
let sector = l.int(first + 22, "сектор", 0, ew::SECTORS as i64)? as u8;
|
|
let low = l.flag(first + 23, "низко")?;
|
|
let jammed = l.flag(first + 24, "подавлен")?;
|
|
let smart = l.flag(first + 25, "умный")?;
|
|
let hold = l.int(first + 26, "задержка", 0, u16::MAX as i64)? as u16;
|
|
let best = match l.word(first + 27, "лучшее приближение")? {
|
|
"-" => f64::INFINITY,
|
|
_ => l.num(first + 27, "лучшее приближение")?,
|
|
};
|
|
let pat = l.int(first + 28, "такт приближения", 0, 1 << 30)? as u32;
|
|
let proute = match l.word(first + 29, "точек приближения")? {
|
|
"-" => usize::MAX,
|
|
_ => l.count(first + 29, "точек приближения", MAX_ROUTE)?,
|
|
};
|
|
let mut at = first + 30;
|
|
let mut route = Vec::new();
|
|
if l.word(at, "маршрут")? != "-" {
|
|
let n = l.count(at, "точек маршрута", MAX_ROUTE)?;
|
|
at += 1;
|
|
for _ in 0..n {
|
|
route.push(DVec3::new(l.num(at, "маршрут X")?, l.num(at + 1, "маршрут Y")?, l.num(at + 2, "маршрут Z")?));
|
|
at += 3;
|
|
}
|
|
} else {
|
|
at += 1;
|
|
}
|
|
let drone = Drone {
|
|
id,
|
|
kind,
|
|
pos,
|
|
vel,
|
|
target,
|
|
flight,
|
|
roll: 0.0,
|
|
spin: 0.0,
|
|
age,
|
|
engaged,
|
|
route,
|
|
low,
|
|
jammed,
|
|
sector,
|
|
smart,
|
|
nav: Nav::default(),
|
|
err,
|
|
intent,
|
|
aim: ew::Aim { unit, since, switches, confidence: conf },
|
|
hold,
|
|
pace: Pace { best, at: pat, route: proute },
|
|
};
|
|
Ok((drone, at))
|
|
}
|
|
|
|
/// The jobs' priorities and intents as the report words them (tests and diagnostics).
|
|
#[cfg(test)]
|
|
impl Sim {
|
|
pub(super) fn pending_intents(&self) -> Vec<(u32, ew::Intent)> {
|
|
self.retargets.iter().map(|j| (j.id, j.intent)).collect()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod durable_tests {
|
|
use super::*;
|
|
|
|
fn contact(id: u32, kind: SamKind, at: DVec3, tick: u64, seen: ew::Seen, launches: u16) -> ew::Contact {
|
|
ew::Contact { id, kind, at, tick, seen, emission: Some(tick), destroyed: None, launches }
|
|
}
|
|
|
|
/// A small force, a few known contacts and a relief version, as a smart raid leaves them.
|
|
fn raid_state(seed: u64) -> Sim {
|
|
let mut sim = Sim::new(seed);
|
|
let grid = raid::Grid { min: DVec3::new(-1024.0, 0.0, -1024.0), cell: 32.0, size: 64 };
|
|
let mut heights = vec![71.0f32; (grid.size * grid.size) as usize];
|
|
for i in 0..8 {
|
|
heights[(i * grid.size + 3) as usize] = f32::NAN;
|
|
}
|
|
sim.known_relief = Some(std::sync::Arc::new(ew::KnownRelief::new(grid, heights)));
|
|
let mut ids = Vec::new();
|
|
for (k, kind) in [SamKind::S400, SamKind::Radar, SamKind::Ew].into_iter().enumerate() {
|
|
let id = sim.id();
|
|
let at = DVec3::new(-400.0 + k as f64 * 400.0, 70.0, 0.0);
|
|
let c = contact(id, kind, at, 10, if kind == SamKind::Ew { ew::Seen::Jamming } else { ew::Seen::Emission }, k as u16);
|
|
sim.intel = ew::Intel::restore([c].to_vec(), [0; ew::SECTORS], [0; ew::SECTORS]);
|
|
ids.push(id);
|
|
}
|
|
sim.intel = ew::Intel::restore(
|
|
ids.iter().enumerate().map(|(k, id)| contact(*id, [SamKind::S400, SamKind::Radar, SamKind::Ew][k], DVec3::new(-400.0 + k as f64 * 400.0, 70.0, 0.0), 10, ew::Seen::Emission, k as u16)).collect(),
|
|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
|
|
[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
|
|
);
|
|
sim.tick = 120;
|
|
sim.job_next = 7;
|
|
// One drone in the air with a route and an aim, one still on the ground.
|
|
let mut flying = sim.make_drone(DroneKind::Kh22, DVec3::new(-900.0, 130.0, -300.0), DVec3::X, DVec3::new(-400.0, 70.0, 0.0));
|
|
flying.smart = true;
|
|
flying.intent = ew::Intent::React;
|
|
flying.aim = ew::Aim::unit(ids[0], 100, ew::Confidence::Confirmed);
|
|
flying.target = DVec3::new(-400.0, 70.0, 0.0) + flying.err;
|
|
flying.route = vec![DVec3::new(-900.0, 70.0, -300.0), DVec3::new(-600.0, 70.0, -100.0), DVec3::new(-400.0, 70.0, 0.0)];
|
|
flying.low = true;
|
|
flying.jammed = true;
|
|
flying.sector = 5;
|
|
flying.age = 77;
|
|
sim.drones.push(flying);
|
|
let mut queued = sim.make_drone(DroneKind::Geran3, DVec3::new(-1000.0, 90.0, 200.0), DVec3::X, DVec3::new(400.0, 70.0, 0.0));
|
|
queued.smart = true;
|
|
queued.intent = ew::Intent::Sead;
|
|
queued.aim = ew::Aim::unit(ids[1], 110, ew::Confidence::Probable);
|
|
queued.route = vec![DVec3::new(-1000.0, 70.0, 200.0), DVec3::new(400.0, 70.0, 0.0)];
|
|
let queued_id = queued.id;
|
|
sim.queue.push((300, queued));
|
|
// Two pending jobs: one of the plan, one a replacement, both with their own version.
|
|
let job = |id, drone, aim, unit, version, intent| {
|
|
ew::RouteJob::restored(id, drone, aim, unit, version, intent, std::sync::Arc::new(sim.intel.contacts().values().copied().collect()), sim.known_relief.clone())
|
|
};
|
|
sim.retargets.push_back(job(5, sim.drones[0].id, sim.drones[0].target, ids[0], 100, ew::Intent::React));
|
|
let queued_target = sim.queue[0].1.target;
|
|
sim.retargets.push_back(job(6, queued_id, queued_target, ids[1], 120, ew::Intent::Replace));
|
|
sim
|
|
}
|
|
|
|
#[test]
|
|
fn the_air_state_round_trips_every_job_field() {
|
|
let sim = raid_state(71);
|
|
let text = sim.air_text().expect("a raid state has something to keep");
|
|
let save = Sim::parse_air(&text).expect("the written section must read back").expect("the section is there");
|
|
let mut back = Sim::new(1);
|
|
back.restore_air(save);
|
|
assert_eq!(back.tick, sim.tick);
|
|
assert_eq!(back.job_next, sim.job_next);
|
|
assert_eq!(back.intel.sectors(), sim.intel.sectors());
|
|
assert_eq!(back.intel.contacts().len(), sim.intel.contacts().len());
|
|
for (id, c) in sim.intel.contacts() {
|
|
let b = back.intel.contacts().get(id).expect("a contact was lost");
|
|
assert_eq!(b.kind, c.kind);
|
|
assert!((b.at.distance(c.at)).abs() < 0.02 && b.tick == c.tick && b.seen == c.seen && b.launches == c.launches);
|
|
}
|
|
assert_eq!(back.drones.len(), 1);
|
|
let (a, b) = (&sim.drones[0], &back.drones[0]);
|
|
assert_eq!((a.id, a.kind, a.smart, a.intent, a.sector, a.age, a.low, a.jammed), (b.id, b.kind, b.smart, b.intent, b.sector, b.age, b.low, b.jammed));
|
|
assert_eq!((a.aim.unit, a.aim.since, a.aim.switches, a.aim.confidence), (b.aim.unit, b.aim.since, b.aim.switches, b.aim.confidence));
|
|
assert!(a.pos.distance(b.pos) < 0.02 && a.target.distance(b.target) < 0.02 && a.vel.distance(b.vel) < 0.02);
|
|
assert_eq!(a.route.len(), b.route.len());
|
|
assert!(a.route.iter().zip(&b.route).all(|(x, y)| x.distance(*y) < 0.02));
|
|
assert_eq!(back.queue.len(), 1);
|
|
assert_eq!(back.queue[0].0, 300);
|
|
let (qa, qb) = (&sim.queue[0].1, &back.queue[0].1);
|
|
assert_eq!((qa.id, qa.intent, qa.aim.unit), (qb.id, qb.intent, qb.aim.unit));
|
|
assert!(qa.route.iter().zip(&qb.route).all(|(x, y)| x.distance(*y) < 0.02));
|
|
// The jobs keep their ids, aims, units, versions, priorities and intents; so do their pictures
|
|
// (the same version shares one) and the land they plan over.
|
|
assert_eq!(back.retargets.len(), 2);
|
|
for (j, b) in sim.retargets.iter().zip(&back.retargets) {
|
|
assert_eq!((j.id, j.drone, j.unit, j.version, j.priority(), j.intent), (b.id, b.drone, b.unit, b.version, b.priority(), b.intent));
|
|
assert!(j.aim.distance(b.aim) < 0.02);
|
|
assert_eq!(j.relief.is_some(), b.relief.is_some());
|
|
}
|
|
let (ra, rb) = (sim.known_relief.as_ref().unwrap(), back.known_relief.as_ref().unwrap());
|
|
assert_eq!(ra.heights().len(), rb.heights().len());
|
|
assert!(ra.heights().iter().zip(rb.heights()).all(|(x, y)| (x.is_nan() && y.is_nan()) || x == y));
|
|
// Nothing is written for an empty sky.
|
|
assert!(Sim::new(3).air_text().is_none());
|
|
}
|
|
|
|
/// 40 smart drones, one adaptive tick, a bounded number of aims and jobs: the state a save is
|
|
/// taken in while routes are still being worked out.
|
|
fn pending_raid(seed: u64) -> Sim {
|
|
let mut sim = Sim::new(seed);
|
|
let mut contacts = Vec::new();
|
|
for k in 0..8 {
|
|
let id = sim.id();
|
|
contacts.push(contact(id, SamKind::S400, DVec3::new(-560.0 + k as f64 * 160.0, 70.0, -320.0), 0, ew::Seen::Emission, 0));
|
|
}
|
|
sim.intel = ew::Intel::restore(contacts, [0; ew::SECTORS], [0; ew::SECTORS]);
|
|
for i in 0..40 {
|
|
let from = DVec3::new(-1800.0, 100.0, -800.0 + i as f64 * 40.0);
|
|
let mut d = sim.make_drone(DroneKind::Kh22, from, DVec3::X, DVec3::new(1800.0, 70.0, 1800.0));
|
|
d.smart = true;
|
|
d.route = vec![from, DVec3::new(1800.0, 70.0, 1800.0)];
|
|
sim.queue.push((0, d));
|
|
}
|
|
sim.tick = 40;
|
|
sim.adapt();
|
|
sim
|
|
}
|
|
|
|
#[test]
|
|
fn a_pending_route_continues_after_a_save_and_a_load() {
|
|
let mut original = pending_raid(73);
|
|
assert!(!original.retargets.is_empty(), "the test no longer saves mid-queue");
|
|
let text = original.air_text().expect("a queued raid must be durable");
|
|
let mut restored = Sim::new(73);
|
|
restored.restore_air(Sim::parse_air(&text).unwrap().unwrap());
|
|
assert_eq!(restored.retargets.len(), original.retargets.len(), "the pending jobs did not survive the save");
|
|
assert_eq!(restored.retarget_route_state(), original.retarget_route_state(), "the restored jobs differ from the saved ones");
|
|
// Both go on: the same adaptive ticks, the same jobs finished, the same routes.
|
|
for _ in 0..400 {
|
|
original.tick += 1;
|
|
restored.tick += 1;
|
|
original.adapt();
|
|
restored.adapt();
|
|
assert_eq!(restored.retarget_route_state(), original.retarget_route_state(), "the restored queue drifted");
|
|
if original.retargets.is_empty() && restored.retargets.is_empty() && original.queue.iter().all(|(_, d)| d.aim.unit != 0) {
|
|
break;
|
|
}
|
|
}
|
|
assert!(original.retargets.is_empty() && restored.retargets.is_empty(), "the restored queue never finished");
|
|
// Every drone of the restored raid has a real route, and every aim it was given is one it planned.
|
|
assert!(restored.queue.iter().all(|(_, d)| !d.route.is_empty() && d.aim.unit != 0));
|
|
assert!(restored.queue.iter().all(|(_, d)| d.route.last().is_some_and(|p| p.distance(d.target) < 1e-6)));
|
|
}
|
|
|
|
// #127: the section has a byte bound of its own. A raid with more (and longer-routed) drones than a
|
|
// save can hold keeps as many as fit, and every job it writes belongs to a drone that was written.
|
|
#[test]
|
|
fn the_section_stays_inside_its_byte_bound() {
|
|
let mut sim = Sim::new(101);
|
|
for i in 0..600 {
|
|
let from = DVec3::new(-2000.0 + i as f64, 120.0, 0.0);
|
|
let mut d = sim.make_drone(DroneKind::Kh22, from, DVec3::X, DVec3::new(2000.0, 70.0, 0.0));
|
|
d.smart = true;
|
|
d.route = (0..200).map(|k| DVec3::new(-2000.0 + k as f64 * 20.0, 70.0, 0.0)).collect();
|
|
sim.drones.push(d);
|
|
}
|
|
let text = sim.air_text().expect("a sky full of drones is durable");
|
|
assert!(text.len() <= MAX_BYTES, "the section grew to {} bytes", text.len());
|
|
let save = Sim::parse_air(&text).expect("a bounded section must read back").unwrap();
|
|
assert!(save.drones.len() <= MAX_DRONES);
|
|
assert!(save.drones.len() > 100, "the bound left almost nothing");
|
|
}
|
|
|
|
#[test]
|
|
fn stale_ghost_and_duplicate_jobs_are_cancelled() {
|
|
let mut sim = pending_raid(79);
|
|
let kept = sim.retargets.len();
|
|
let some = sim.retargets[0].clone();
|
|
// A job for a drone that is not here.
|
|
sim.retargets.push_back(ew::RouteJob::restored(900, 999_999, DVec3::ZERO, 0, sim.tick, ew::Intent::Plan, std::sync::Arc::new(Vec::new()), None));
|
|
// A job whose aim is no longer its drone's.
|
|
let mut stale = some.clone();
|
|
stale.id = 901;
|
|
stale.aim += DVec3::X * 40.0;
|
|
sim.retargets.push_back(stale);
|
|
// An older duplicate for a drone that already has a newer job.
|
|
let mut older = some.clone();
|
|
older.id = 902;
|
|
older.version = sim.tick.saturating_sub(1);
|
|
sim.retargets.push_back(older);
|
|
// A job older than the TTL.
|
|
let mut old = sim.retargets[0].clone();
|
|
old.id = 903;
|
|
old.version = sim.tick.saturating_sub(ew::JOB_TTL + 1);
|
|
sim.retargets.push_back(old);
|
|
let cancelled = sim.prune_air();
|
|
assert_eq!(cancelled, 4, "the stale, ghost, duplicate and old jobs were not all cancelled");
|
|
assert_eq!(sim.retargets.len(), kept);
|
|
assert!(sim.retargets.iter().all(|j| j.id < 900));
|
|
}
|
|
|
|
#[test]
|
|
fn a_job_for_a_unit_the_picture_lost_is_cancelled_on_load() {
|
|
let sim = pending_raid(83);
|
|
let unit = sim.retargets[0].unit;
|
|
let text = sim.air_text().unwrap();
|
|
assert!(sim.intel.contacts().contains_key(&unit));
|
|
// Cut the job's unit out of the saved picture (and its count): the job cannot stand behind it.
|
|
let mut lines: Vec<String> = text.lines().map(str::to_string).collect();
|
|
let head = lines.iter().position(|l| l.starts_with("air ")).unwrap();
|
|
let mut w: Vec<String> = lines[head].split_whitespace().map(str::to_string).collect();
|
|
w[7] = (w[7].parse::<usize>().unwrap() - 1).to_string();
|
|
lines[head] = w.join(" ");
|
|
lines.retain(|l| !l.starts_with(&format!("aircontact {unit} ")));
|
|
let cut = lines.join("\n") + "\n";
|
|
let mut restored = Sim::new(83);
|
|
let cancelled = restored.restore_air(Sim::parse_air(&cut).expect("the cut section is still well formed").unwrap());
|
|
assert!(cancelled > 0, "a job for a unit the picture lost was kept");
|
|
assert!(restored.retargets.iter().all(|j| j.unit != unit), "the ghost job survived the load");
|
|
}
|
|
|
|
#[test]
|
|
fn a_damaged_air_section_is_refused_with_its_line_and_field() {
|
|
let sim = raid_state(89);
|
|
let text = sim.air_text().unwrap();
|
|
assert!(Sim::parse_air("sam s400 0 70 0 0\n").unwrap().is_none(), "an older save must read as an empty sky");
|
|
let e = Sim::parse_air(&text.replace("air 1 ", "air 2 ")).err().expect("a future version was accepted");
|
|
assert!(e.contains("версия"), "{e}");
|
|
let e = Sim::parse_air(&format!("{text}airbogus 1\n")).err().expect("a foreign line in the section was accepted");
|
|
assert!(e.contains("неизвестная строка"), "{e}");
|
|
// A count that does not match the lines is a cut-off file, refused rather than half restored.
|
|
let cut: String = text.lines().filter(|l| !l.starts_with("airjob ")).map(|l| format!("{l}\n")).collect();
|
|
let e = Sim::parse_air(&cut).err().expect("a cut-off section was accepted");
|
|
assert!(e.contains("заданий"), "{e}");
|
|
// A coordinate that is not a number, and a broken relief run, name their line.
|
|
let mut lines: Vec<String> = text.lines().map(str::to_string).collect();
|
|
let drone = lines.iter().position(|l| l.starts_with("airdrone ")).unwrap();
|
|
let mut w: Vec<String> = lines[drone].split_whitespace().map(str::to_string).collect();
|
|
w[3] = "NaN".into();
|
|
lines[drone] = w.join(" ");
|
|
let e = Sim::parse_air(&lines.join("\n")).err().expect("a non-finite coordinate was accepted");
|
|
assert!(e.contains(&format!("строка {}", drone + 1)) && e.contains("дрон X"), "{e}");
|
|
let e = Sim::parse_air(&text.replace("airrelief 0 ", "airrelief 0 x ")).err().expect("a broken relief line was accepted");
|
|
assert!(e.contains("рельеф"), "{e}");
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
impl Sim {
|
|
/// The pending jobs and the routes of their drones, for the save/restore comparison.
|
|
pub(super) fn retarget_route_state(&self) -> Vec<(u32, u32, u32, u64, u8, i64, Vec<(i64, i64, i64)>)> {
|
|
self.retargets
|
|
.iter()
|
|
.map(|j| {
|
|
let route = self
|
|
.queue
|
|
.iter()
|
|
.map(|(_, d)| d)
|
|
.chain(self.drones.iter())
|
|
.find(|d| d.id == j.drone)
|
|
.map(|d| d.route.iter().map(|p| ((p.x * 100.0).round() as i64, (p.y * 100.0).round() as i64, (p.z * 100.0).round() as i64)).collect())
|
|
.unwrap_or_default();
|
|
let q = |v: f64| (v * 100.0).round() as i64;
|
|
(j.id, j.drone, j.unit, j.version, j.priority(), q(j.aim.x), route)
|
|
})
|
|
.collect()
|
|
}
|
|
}
|