Smart v2 on top of #146: one public picture, mark prices, bounded refresh, bearing window (#149)
build / mod (push) Failing after 30s

Re-applied the genuinely new #149 features onto kimi-work, REUSING the already-integrated
#146 infrastructure (KnowledgeSnapshot { tick, contacts, marks }, knowledge_now(),
Plan.knowledge, RouteJob.known, versioned price_grid_known and restore). No #146 scaffolding
is duplicated: one snapshot per order, prices over known.tick, versioned restore are kept
exactly as they were. The only additive change to KnowledgeSnapshot is observations().

New #149 layer:
- observe::Observation + observe::merge: Contact and Mark become one public hint, matched by
  public features only (area overlap + exact category); coarse Unknown/contradicting marks stay
  separate, the contact's kind/fix are never rewritten, recon.truth and real ids are not used.
  One Observation::rank scale replaces the two ranks in radar_strikes, choose_target and the
  adaptive picks (kimi-work's slice signatures kept).
- price_grid_known prices marks: a trusted launcher/gun/jammer mark prices its published
  category envelope weighted by confidence (Confirmed x1, Probable x0.5); a radar mark feeds
  the network belief; a mark matched to a contact is priced once through the contact; a
  doubtful mark prices nothing.
- Bounded refresh of the unreleased portion: ew::Refresh with absolute deadline
  REFRESH_WINDOW=600; step_refresh re-aims queued Plan/Sead drones once on a report (typed
  Intent::Refresh, SEAD priority) within SWITCH_CAP and assignment budgets; no report never
  delays a launch.
- Bearing window: Intel.outcomes bounded VecDeque (48 entries, 12000-tick window); best_bearing
  adapts exploration share by typed BearingReason (few/stale/conditions-changed/exploiting);
  conditions are a fingerprint of the public picture, never hidden state. bearing_report() and
  bearing/refresh_*/observations fields in EnemyPictureReport. Legacy fixed share kept.
- examples/smart_bench runner (simple/current/candidate, seeds 1/7/42, open/hills/config-change/
  recon-lost, JSON+lines); Sim::smart_legacy reproduces current Smart; harness::run_with_hook.
  Light modes and bounded jobs unchanged; policy reads no health/charges/hidden switches/positions.

Tests: smart_tests + observe::tests (metamorphic hidden-layout, public dedup, marks in prices,
one version per order in both modes, bounded refresh fires-once/never-pauses, bearing window and
reasons, durable window + Intent::Refresh). The relief-version regression fixture's wall is
widened in z so it crosses any east-west route after the candidate's assignment-order change.
cargo test passes: airdef-core 326 lib + 8 scenarios; airdef-mod 113 lib + core_boundary + 5 scenarios.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
2026-11-21 10:57:04 +03:00
parent b796a439df
commit 32748b116c
11 changed files with 1435 additions and 84 deletions
+41 -1
View File
@@ -72,6 +72,9 @@ pub struct Scenario {
pub ew: bool,
/// Ticks a truck on a job may stand still before it counts as stuck.
pub stuck_after: u64,
/// The smart enemy runs the legacy picks (#149's comparison runner): separate hint lists,
/// the lifetime bearing tally, no mark pricing and no refresh of the unreleased portion.
pub legacy: bool,
}
impl Scenario {
@@ -87,6 +90,7 @@ impl Scenario {
stop_at_end: true,
ew: false,
stuck_after: 600,
legacy: false,
}
}
pub fn unit(&mut self, kind: SamKind, x: f64, z: f64) -> &mut Unit {
@@ -138,6 +142,18 @@ pub struct Report {
pub intents: String,
/// The most aim switches one drone went through.
pub switches_max: u16,
/// Smart drones seen over the run (#149's comparison).
pub smart_seen: u32,
/// The share of them whose last aim was a live public hint when last seen (#149).
pub useful_share: f64,
/// Distinct aim units over the smart drones seen, per drone (#149).
pub diversity: f64,
/// The share of smart drones switched twice or more (#149's jitter).
pub jittery_share: f64,
/// The bearing picker's last typed reason (#149).
pub bearing_reason: String,
/// Aims the bounded refresh re-chose (#149).
pub refresh_applied: u32,
}
/// The last intent every smart drone of the run was seen carrying, as `name:count`.
@@ -146,7 +162,7 @@ fn intent_counts(seen: &HashMap<u32, &'static str>) -> String {
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(",")
["plan", "sead", "react", "replace", "refresh"].iter().map(|k| format!("{k}:{}", counts.get(*k).copied().unwrap_or(0))).collect::<Vec<_>>().join(",")
}
fn finite(v: DVec3) -> bool {
@@ -154,7 +170,14 @@ fn finite(v: DVec3) -> bool {
}
pub fn run(sc: &Scenario) -> Report {
run_with_hook(sc, &mut |_, _| {})
}
/// The same, with a hook called after every tick (#149's comparison runner): a scenario may
/// change the defence between waves or shoot a recon flight down before its report.
pub fn run_with_hook(sc: &Scenario, hook: &mut dyn FnMut(u64, &mut Sim)) -> Report {
let mut sim = Sim::new(sc.seed);
sim.smart_legacy = sc.legacy;
sim.damage = false; // explosions would change the land the height function describes
for u in &sc.units {
let id = sim.id();
@@ -183,6 +206,8 @@ pub fn run(sc: &Scenario) -> Report {
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();
// drone id -> (last aim unit, whether the picture held it live then, switches) (#149).
let mut decisions: HashMap<u32, (u32, bool, u16)> = 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.
@@ -205,6 +230,7 @@ pub fn run(sc: &Scenario) -> Report {
ground.world.serve(&sc.terrain, sections, now);
let dt = t.elapsed();
times.push(dt);
hook(now, &mut sim);
if planning {
r.planning += dt;
r.planning_ticks += 1;
@@ -220,6 +246,8 @@ pub fn run(sc: &Scenario) -> Report {
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());
let unit = d.aim_unit();
decisions.insert(d.id, (unit, unit != 0 && sim.known_live(unit), d.aim_switches()));
}
}
// The air section a save would take, sampled when the sky is fullest (writing it every tick
@@ -271,6 +299,18 @@ pub fn run(sc: &Scenario) -> Report {
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.smart_seen = decisions.len() as u32;
if !decisions.is_empty() {
let n = decisions.len() as f64;
r.useful_share = decisions.values().filter(|(_, live, _)| *live).count() as f64 / n;
let mut units: Vec<u32> = decisions.values().map(|(u, _, _)| *u).collect();
units.sort_unstable();
units.dedup();
r.diversity = units.len() as f64 / n;
r.jittery_share = decisions.values().filter(|(_, _, s)| *s >= 2).count() as f64 / n;
}
r.bearing_reason = sim.bearing_report().reason.name().to_string();
r.refresh_applied = sim.refresh_applied();
r.tick_total = times.iter().sum();
times.sort();
if !times.is_empty() {
+187
View File
@@ -0,0 +1,187 @@
//! Smart v2 comparison runner (#149): the simple mode, the current (legacy) Smart and the
//! candidate, on fixed seeds and one scenario set — open map, hills, a configuration changed
//! between waves, and a recon flight shot down before its report.
//!
//! It prints one JSON array of rows: the share of useful decisions (a smart drone whose last
//! aim was a live public hint), the diversity of aims, the reasons (intents) on the review,
//! the share of jittery drones (two switches or more), the bearing picker's typed reason, the
//! refresh count, and the CPU/worst-job figures. The goal is interesting counterplay and clear
//! mistakes, not a maximised hit count — read the reasons and the jitter beside the losses.
//!
//! cargo run --release --example smart_bench
#[path = "sim_run/harness.rs"]
mod harness;
use airdef::sim::{Aim, Approach, DroneKind, Sam, SamKind, Sim};
use glam::DVec3;
use harness::{Report, Scenario, Terrain};
#[derive(Clone, Copy, PartialEq)]
enum Mode {
Simple,
Current,
Candidate,
}
impl Mode {
fn name(self) -> &'static str {
match self {
Mode::Simple => "simple",
Mode::Current => "current",
Mode::Candidate => "candidate",
}
}
fn apply(self, sc: &mut Scenario) {
sc.legacy = self == Mode::Current;
let aim = match self {
Mode::Simple => Aim::ObjectsAndSams,
_ => Aim::Smart,
};
for raid in &mut sc.raids {
raid.aim = aim;
}
}
}
fn esc(s: &str) -> String {
s.chars().flat_map(|c| match c {
'"' => "\\\"".chars().collect::<Vec<_>>(),
'\\' => "\\\\".chars().collect::<Vec<_>>(),
c => vec![c],
}).collect()
}
fn row(sc: &str, mode: Mode, r: &Report) -> String {
format!(
"{{\"scenario\":\"{}\",\"mode\":\"{}\",\"seed\":{},\"ticks\":{},\"all_ended\":{},\"launched\":{},\"kills\":{},\"hits\":{},\"fired\":{},\"sams_lost\":{},\"smart_seen\":{},\"useful_share\":{:.3},\"diversity\":{:.3},\"jittery_share\":{:.3},\"intents\":\"{}\",\"bearing_reason\":\"{}\",\"refresh_applied\":{},\"switches_max\":{},\"retargets_max\":{},\"tick_p95_ms\":{:.3},\"tick_max_ms\":{:.3},\"planning_ms\":{:.1},\"air_bytes\":{}}}",
esc(sc),
mode.name(),
r.seed,
r.ticks_run,
r.all_ended,
r.launched,
r.kills,
r.hits,
r.fired,
r.sams_lost,
r.smart_seen,
r.useful_share,
r.diversity,
r.jittery_share,
esc(&r.intents),
esc(&r.bearing_reason),
r.refresh_applied,
r.switches_max,
r.retargets_max,
r.tick_p95.as_secs_f64() * 1000.0,
r.tick_max.as_secs_f64() * 1000.0,
r.planning.as_secs_f64() * 1000.0,
r.air_bytes,
)
}
/// An open map: a ring of systems on flat land, one combined strike.
fn open() -> Scenario {
let mut sc = Scenario::new("open");
sc.terrain = Terrain::Flat(70);
for i in 0..18 {
let a = i as f64 * 2.399_963;
let r = 120.0 + (i as f64 / 18.0) * 320.0;
let kind = [SamKind::Radar, SamKind::S400, SamKind::Pantsir, SamKind::Ew, SamKind::Tor][i % 5];
sc.unit(kind, a.sin() * r, a.cos() * r).heading = a;
}
sc.raids.push(harness::RaidSpec {
kinds: vec![(DroneKind::Gerbera, 6), (DroneKind::Shahed, 10), (DroneKind::Kh101, 3), (DroneKind::Kh22, 2), (DroneKind::Lancet, 3)],
approach: Approach::AllSides,
aim: Aim::Smart,
dist: 500.0,
at: 1,
});
sc.ticks = 20 * 60 * 6;
sc
}
/// Hills: the standard big smart scenario's terrain and force.
fn hills() -> Scenario {
let mut sc = harness::big_smart();
sc.name = "hills".into();
sc.ticks = 20 * 60 * 6;
sc
}
/// Two waves with the defence changed between them: a radar moves unobserved, the EW stations
/// switch on, and a fresh battery appears. The second wave's picture must earn what it knows.
fn config_change() -> Scenario {
let mut sc = open();
sc.name = "config-change".into();
sc.raids.push(harness::RaidSpec {
kinds: vec![(DroneKind::Shahed, 8), (DroneKind::Geran3, 4), (DroneKind::Kh22, 2), (DroneKind::Iskander, 2)],
approach: Approach::TwoSectors,
aim: Aim::Smart,
dist: 600.0,
at: 4200,
});
sc.ticks = 20 * 60 * 10;
sc
}
/// A recon flight shot down before its report: the strike must fly on the picture it had, and
/// the bounded refresh must never hold the raid waiting for a report that will not come.
fn recon_lost() -> Scenario {
let mut sc = open();
sc.name = "recon-lost".into();
sc.ticks = 20 * 60 * 6;
sc
}
pub fn main() {
let seeds = [1u64, 7, 42];
let scenarios: [(&str, fn() -> Scenario); 4] = [("open", open), ("hills", hills), ("config-change", config_change), ("recon-lost", recon_lost)];
let modes = [Mode::Simple, Mode::Current, Mode::Candidate];
let mut rows = Vec::new();
for (name, make) in scenarios {
for mode in modes {
for &seed in &seeds {
let r = run(mode, name, make, seed);
rows.push(row(name, mode, &r));
eprintln!("{name} {} seed {seed}: useful {:.2} diversity {:.2} jitter {:.2} kills {} hits {} reasons {} bearing {} refresh {}", mode.name(), r.useful_share, r.diversity, r.jittery_share, r.kills, r.hits, r.intents, r.bearing_reason, r.refresh_applied);
}
}
}
println!("[{}]", rows.join(",\n"));
}
fn run(mode: Mode, name: &str, make: fn() -> Scenario, seed: u64) -> Report {
let mut sc = make();
sc.seed = seed;
mode.apply(&mut sc);
match name {
"config-change" => {
let mut changed = false;
harness::run_with_hook(&sc, &mut |now, sim: &mut Sim| {
if !changed && now >= 3600 && !sim.planning() {
changed = true;
if let Some(radar) = sim.sams.iter_mut().find(|s| s.kind == SamKind::Radar) {
radar.pos += DVec3::new(300.0, 0.0, -200.0);
}
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::Pantsir, DVec3::new(-200.0, 70.0, 250.0), 0.0));
sim.set_ew(true);
}
})
}
"recon-lost" => {
let mut killed = false;
harness::run_with_hook(&sc, &mut |now, sim: &mut Sim| {
if !killed && now >= 120 {
let recon: Vec<u32> = sim.drones.iter().filter(|d| sim.is_recon_drone(d.id)).map(|d| d.id).collect();
if !recon.is_empty() {
sim.drones.retain(|d| !recon.contains(&d.id));
killed = true;
}
}
})
}
_ => harness::run(&sc),
}
}
+14 -2
View File
@@ -182,7 +182,7 @@ pub fn picture_lines(pic: &EnemyPictureReport) -> Vec<String> {
#[cfg(test)]
mod tests {
use super::*;
use crate::sim::{AimReport, Confidence, EnemyPictureReport, ReconReport, ReconSortieReport};
use crate::sim::{AimReport, BearingReport, Confidence, EnemyPictureReport, ReconReport, ReconSortieReport};
use glam::DVec3;
fn mark(id: u32, category: &'static str, role: Option<&'static str>, quality: &'static str, confidence: Confidence, age: u64) -> ReconReport {
@@ -198,7 +198,19 @@ mod tests {
}
fn picture(recon: Vec<ReconReport>, recon_sorties: Vec<ReconSortieReport>, aims: Vec<AimReport>) -> EnemyPictureReport {
EnemyPictureReport { now: 1000, contacts: Vec::new(), aims, pending: Vec::new(), work_per_tick: 4, recon, recon_sorties }
EnemyPictureReport {
now: 1000,
contacts: Vec::new(),
aims,
pending: Vec::new(),
work_per_tick: 4,
recon,
recon_sorties,
observations: Vec::new(),
bearing: BearingReport::default(),
refresh_waiting: false,
refresh_applied: 0,
}
}
// The reason names all three factors with the planner's own weights, and they sum to the priority.
+36 -6
View File
@@ -51,6 +51,8 @@ pub struct AirSave {
job_next: u32,
kills: [u32; ew::SECTORS],
hits: [u32; ew::SECTORS],
/// The bearing memory's small window of recent outcomes (#149).
outcomes: Vec<ew::Learned>,
contacts: Vec<ew::Contact>,
drones: Vec<Drone>,
queue: Vec<(u64, Drone)>,
@@ -247,6 +249,16 @@ impl Sim {
head += &format!(" {v}");
}
head += "\n";
// The bearing window (#149): bounded, and optional — an older save without it loads with
// an empty window and the lifetime tally it does carry.
let outcomes: Vec<&ew::Learned> = self.intel.outcomes().iter().take(ew::MAX_OUTCOMES).collect();
if !outcomes.is_empty() {
head += &format!("airlearn {}", outcomes.len());
for o in &outcomes {
head += &format!(" {} {} {}", o.sector, o.tick, u8::from(o.killed));
}
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();
@@ -319,7 +331,7 @@ impl Sim {
.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() {
if drone_count == 0 && queued_count == 0 && jobs.is_empty() && contacts.is_empty() && self.recon.is_empty() && outcomes.is_empty() {
return None;
}
let head = head.replacen(
@@ -467,6 +479,7 @@ impl Sim {
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 outcomes: Vec<ew::Learned> = Vec::new();
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();
@@ -499,6 +512,21 @@ impl Sim {
}
intel = Some(v);
}
"airlearn" => {
let n = l.count(1, "исходы", ew::MAX_OUTCOMES)?;
if w.len() != 2 + n * 3 {
return Err(l.bad("исходы", "нужны сектор, такт и исход каждого"));
}
if !outcomes.is_empty() {
return Err(l.bad("исходы", "окно записано дважды"));
}
for i in 0..n {
let sector = l.int(2 + i * 3, "сектор исхода", 0, ew::SECTORS as i64 - 1)? as u8;
let t = l.int(3 + i * 3, "такт исхода", 0, tick as i64)? as u64;
let killed = l.int(4 + i * 3, "исход", 0, 1)? == 1;
outcomes.push(ew::Learned { sector, tick: t, killed });
}
}
"airglobal" => {
if w.len() != 2 {
return Err(l.bad("рельеф", "нужна одна ссылка на версию рельефа"));
@@ -602,7 +630,7 @@ impl Sim {
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"))?;
let intent = intent_of(l.word(9, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react, replace или refresh"))?;
if priority != intent.priority() {
return Err(l.bad("приоритет", "не совпадает с намерением"));
}
@@ -827,6 +855,7 @@ impl Sim {
job_next,
kills,
hits,
outcomes,
contacts: contacts.into_values().collect(),
drones: drones.into_values().collect(),
queue,
@@ -845,7 +874,7 @@ impl Sim {
// 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.intel = ew::Intel::restore(save.contacts.clone(), save.kills, save.hits, save.outcomes.clone());
self.known_relief = save.known_relief;
self.drones = save.drones;
self.queue = save.queue;
@@ -889,7 +918,7 @@ fn parse_drone(l: &Line, first: usize) -> Result<(Drone, usize), String> {
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 intent = intent_of(l.word(first + 12, "намерение")?).ok_or_else(|| l.bad("намерение", "plan, sead, react, replace или refresh"))?;
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;
@@ -982,13 +1011,14 @@ mod durable_tests {
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]);
sim.intel = ew::Intel::restore([c].to_vec(), [0; ew::SECTORS], [0; ew::SECTORS], Vec::new());
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],
Vec::new(),
);
sim.tick = 120;
sim.job_next = 7;
@@ -1074,7 +1104,7 @@ mod durable_tests {
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]);
sim.intel = ew::Intel::restore(contacts, [0; ew::SECTORS], [0; ew::SECTORS], Vec::new());
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));
+377 -55
View File
@@ -45,6 +45,9 @@ pub enum Intent {
/// A replacement: the picture watched the previous aim die or forgot it, and this contact
/// is the nearest live one.
Replace,
/// A bounded refresh (#149): a recon report arrived while the raid's drones were still
/// waiting to launch, and the plan's own picks were re-aimed once on the fresh snapshot.
Refresh,
}
impl Intent {
@@ -54,6 +57,7 @@ impl Intent {
Self::Sead => "sead",
Self::React => "react",
Self::Replace => "replace",
Self::Refresh => "refresh",
}
}
/// The key a save writes and reads.
@@ -61,14 +65,15 @@ impl Intent {
self.name()
}
pub(super) fn from_key(key: &str) -> Option<Self> {
[Self::Plan, Self::Sead, Self::React, Self::Replace].into_iter().find(|i| i.key() == key)
[Self::Plan, Self::Sead, Self::React, Self::Replace, Self::Refresh].into_iter().find(|i| i.key() == key)
}
/// The planner's share of a tick this aim is worth: a planned SEAD job and a reaction to a
/// disclosure are finished before a replacement, and the plan's own objective before both (#127).
/// A refresh of the unreleased portion is worth a SEAD job's share (#149).
pub(super) fn priority(self) -> u8 {
match self {
Self::Plan => 3,
Self::Sead => 2,
Self::Sead | Self::Refresh => 2,
Self::React => 1,
Self::Replace => 0,
}
@@ -246,6 +251,16 @@ pub(super) const JOB_TTL: u64 = 1200;
/// What a cell of land a job's knowledge version does not know costs on top of the open ground
/// (the base cell is 1): unknown land is not free, so a replanned route keeps to what was mapped (#127).
pub(super) const UNKNOWN_LAND: f32 = 6.0;
/// How long a smart raid's unreleased portion may wait for a recon report to refresh its aims
/// (#149). A report due later than this is left to the adaptive ticks; nothing pauses for ever.
pub(super) const REFRESH_WINDOW: u64 = 600;
/// The pending refresh of a raid's unreleased portion (#149): the absolute deadline and the
/// report count it waits to pass. Transient — a save drops it, the launches keep their times.
pub(super) struct Refresh {
pub(super) deadline: u64,
pub(super) reports: u32,
}
/// How a contact's trust decays with age alone (#127). The bands are the only source of
/// confidence: nothing is invented about a unit between observations.
@@ -386,11 +401,19 @@ pub(super) struct KnowledgeSnapshot {
}
impl KnowledgeSnapshot {
pub(super) fn new(tick: u64, contacts: Vec<Contact>, marks: Vec<recon::Mark>) -> Self {
Self { tick, contacts, marks }
}
/// A version that knows nothing: for a job whose picture is empty.
#[cfg(test)]
pub(super) fn empty(tick: u64) -> Self {
Self { tick, contacts: Vec::new(), marks: Vec::new() }
}
/// The one public hint list of this version (#149): contacts and marks merged by public
/// features, ranked on the single scale. The snapshot's own tick ages every hint.
pub(super) fn observations(&self) -> Vec<Observation> {
observe::merge(&self.contacts, &self.marks, self.tick)
}
}
/// The radar reach the enemy's planners price by: the type's published figure, undamaged
@@ -405,14 +428,81 @@ pub(super) fn published_reach(kind: SamKind, drone: DroneKind, height: f64) -> f
radar.min(horizon).max(sight::NEAR)
}
/// One raid outcome the bearing memory keeps (#149): the sector it came from, when, and its fate.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) struct Learned {
pub(super) sector: u8,
pub(super) tick: u64,
pub(super) killed: bool,
}
/// The bearing memory is a small window of the latest outcomes, not a lifetime tally (#149):
/// this many entries, and nothing older than `OUTCOME_WINDOW` is scored.
pub(super) const MAX_OUTCOMES: usize = 48;
pub(super) const OUTCOME_WINDOW: u64 = 12_000;
/// A window whose newest outcome is older than this is stale: the fight may have moved on.
pub(super) const OUTCOME_STALE: u64 = 6_000;
/// Why the bearing picker chose as it did (#149), in typed terms the diagnostic reports.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BearingReason {
/// The legacy fixed-share picker (the comparison runner's "current" mode).
FixedShare,
/// Too few outcomes in the window to trust a best sector: explore more.
FewObservations,
/// The window's newest outcome is old: explore more.
StaleResults,
/// The public picture's shape changed since the outcomes were learned: explore more.
ConditionsChanged,
/// Enough fresh outcomes under unchanged conditions: exploit the best sector.
Exploiting,
}
impl BearingReason {
pub fn name(self) -> &'static str {
match self {
Self::FixedShare => "fixed-share",
Self::FewObservations => "few-observations",
Self::StaleResults => "stale-results",
Self::ConditionsChanged => "conditions-changed",
Self::Exploiting => "exploiting",
}
}
}
/// The bearing picker's last decision, for the diagnostic (#149).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BearingReport {
pub sector: usize,
pub reason: BearingReason,
/// Outcomes scored (the window, not the lifetime tally).
pub observations: usize,
/// The best sector's window score.
pub score: f64,
/// The exploration share this decision used.
pub explore: f64,
}
impl Default for BearingReport {
fn default() -> Self {
Self { sector: 0, reason: BearingReason::FewObservations, observations: 0, score: 0.5, explore: 0.6 }
}
}
#[derive(Default)]
pub(super) struct Intel {
/// Shot down and got through, by approach sector, over every raid.
/// Shot down and got through, by approach sector, over every raid (the lifetime tally the
/// legacy picker scores; the window below is what the candidate forgets and reasons about).
pub kills: [u32; SECTORS],
pub hits: [u32; SECTORS],
/// The last observation of each unit the enemy knows of, by id. One entry per unit:
/// a newer observation replaces the older, so no log ever needs rescanning (#122).
contacts: BTreeMap<u32, Contact>,
/// The small window of recent raid outcomes the bearing picker scores (#149).
outcomes: VecDeque<Learned>,
/// The public picture's shape when the last outcome was learned: a change is a reason to
/// explore, never a read of the hidden force (#149).
conditions: u64,
}
impl Intel {
@@ -423,8 +513,26 @@ impl Intel {
pub(super) fn sectors(&self) -> ([u32; SECTORS], [u32; SECTORS]) {
(self.kills, self.hits)
}
pub(super) fn restore(contacts: Vec<Contact>, kills: [u32; SECTORS], hits: [u32; SECTORS]) -> Self {
Self { kills, hits, contacts: contacts.into_iter().map(|c| (c.id, c)).collect() }
pub(super) fn outcomes(&self) -> &VecDeque<Learned> {
&self.outcomes
}
pub(super) fn restore(contacts: Vec<Contact>, kills: [u32; SECTORS], hits: [u32; SECTORS], outcomes: Vec<Learned>) -> Self {
Self {
kills,
hits,
contacts: contacts.into_iter().map(|c| (c.id, c)).collect(),
outcomes: outcomes.into_iter().take(MAX_OUTCOMES).collect(),
conditions: 0,
}
}
/// One outcome into the window, bounded: the oldest goes first (#149).
pub(super) fn learn(&mut self, sector: usize, killed: bool, now: u64, conditions: u64) {
self.outcomes.push_back(Learned { sector: (sector % SECTORS) as u8, tick: now, killed });
while self.outcomes.len() > MAX_OUTCOMES {
self.outcomes.pop_front();
}
self.conditions = conditions;
}
/// The one writer of contacts: what was seen of `s`, at its place, this moment.
@@ -554,24 +662,77 @@ impl Sim {
}
}
/// What the enemy's raids learned: their drones' fates by sector.
/// What the enemy's raids learned: their drones' fates by sector, into the lifetime tally
/// and the small recent window the bearing picker scores (#149).
pub(super) fn learn(&mut self, sector: usize, killed: bool) {
if killed {
self.intel.kills[sector % SECTORS] += 1;
} else {
self.intel.hits[sector % SECTORS] += 1;
}
let conditions = self.picture_fingerprint();
self.intel.learn(sector, killed, self.tick, conditions);
}
/// The bearing a smart raid comes from: the sector its raids got through best, a little random.
/// The public picture's shape (#149): how many live hints of each category the enemy holds.
/// A fingerprint of beliefs only — no health, magazine, switch or true place is read.
pub(super) fn picture_fingerprint(&self) -> u64 {
let now = self.tick;
let mut h: u64 = 0xCBF2_9CE4_8422_2325;
let mut mix = |v: u64| h = (h ^ v).wrapping_mul(0x0000_0100_0000_01B3);
let mut cats = [0u32; 6];
for c in self.intel.contacts.values().filter(|c| c.live(now)) {
cats[recon::Category::of(c.kind) as usize] += 1;
}
for m in self.recon.marks.values().filter(|m| m.live(now)) {
cats[m.category as usize] += 1;
}
for n in cats {
mix(u64::from(n));
}
h
}
/// The bearing a smart raid comes from (#149). The candidate scores a small window of the
/// latest outcomes, forgets the old ones, and adapts its exploration share to what the
/// window can support — few observations, a stale result or changed public conditions each
/// named as a typed reason. The legacy mode keeps the lifetime tally and the fixed share.
pub(super) fn best_bearing(&mut self) -> f64 {
let score = |i: usize| {
let (k, h) = (self.intel.kills[i] as f64, self.intel.hits[i] as f64);
(h + 1.0) / (k + h + 2.0)
let now = self.tick;
let (pick, report) = if self.smart_legacy {
let score = |i: usize| {
let (k, h) = (self.intel.kills[i] as f64, self.intel.hits[i] as f64);
(h + 1.0) / (k + h + 2.0)
};
let best = (0..SECTORS).max_by(|&a, &b| score(a).total_cmp(&score(b))).unwrap_or(0);
// Unknown sectors are worth a look too.
let pick = if self.rng.chance(0.3) { (self.rng.f() * SECTORS as f64) as usize } else { best };
let observations = self.intel.kills.iter().chain(self.intel.hits.iter()).map(|n| *n as usize).sum();
(pick, BearingReport { sector: pick, reason: BearingReason::FixedShare, observations, score: score(best), explore: 0.3 })
} else {
let window: Vec<&Learned> = self.intel.outcomes.iter().filter(|o| now.saturating_sub(o.tick) <= OUTCOME_WINDOW).collect();
let total = window.len();
let newest = window.iter().map(|o| o.tick).max().unwrap_or(0);
let conditions = self.picture_fingerprint();
let (reason, explore) = if total < 6 {
(BearingReason::FewObservations, 0.6)
} else if now.saturating_sub(newest) > OUTCOME_STALE {
(BearingReason::StaleResults, 0.5)
} else if conditions != self.intel.conditions {
(BearingReason::ConditionsChanged, 0.45)
} else {
(BearingReason::Exploiting, 0.15)
};
let score = |i: usize| {
let k = window.iter().filter(|o| o.sector as usize == i && o.killed).count() as f64;
let h = window.iter().filter(|o| o.sector as usize == i && !o.killed).count() as f64;
(h + 1.0) / (k + h + 2.0)
};
let best = (0..SECTORS).max_by(|&a, &b| score(a).total_cmp(&score(b))).unwrap_or(0);
let pick = if self.rng.chance(explore) { (self.rng.f() * SECTORS as f64) as usize } else { best };
(pick, BearingReport { sector: pick, reason, observations: total, score: score(best), explore })
};
let best = (0..SECTORS).max_by(|&a, &b| score(a).total_cmp(&score(b))).unwrap_or(0);
// Unknown sectors are worth a look too.
let pick = if self.rng.chance(0.3) { (self.rng.f() * SECTORS as f64) as usize } else { best };
self.bearing = report;
(pick as f64 + 0.5 + self.rng.s() * 0.4) / SECTORS as f64 * TAU
}
@@ -592,9 +753,68 @@ impl Sim {
KnowledgeSnapshot { tick: self.tick, contacts: self.picture_of_defences(), marks: self.recon.leads(self.tick) }
}
/// The bounded refresh of a raid's unreleased portion (#149): a recon flight is out, and the
/// plan's own picks may be re-aimed once when a report arrives. The deadline is absolute — no
/// report, no delay: the launches keep their times either way.
pub(super) fn step_refresh(&mut self, out: &mut Out) {
let Some(r) = self.refresh.take() else { return };
if self.tick > r.deadline {
return;
}
if self.recon.reports <= r.reports {
self.refresh = Some(r);
return;
}
// A report arrived: one fresh snapshot, one bounded pass over the drones still waiting
// to launch. Only the plan's own picks are re-aimed, once, within the switch cap.
let knowledge = self.knowledge_now();
let obs = knowledge.observations();
let known = Arc::new(knowledge);
let relief = self.known_relief.clone();
let now = self.tick;
let mut per: HashMap<u32, usize> = HashMap::new();
let mut assigned = 0usize;
let mut changed = 0u32;
let mut job_next = self.job_next;
let mut jobs: Vec<RouteJob> = Vec::new();
for (_, d) in self.queue.iter_mut().filter(|(_, d)| d.smart && matches!(d.intent, Intent::Plan | Intent::Sead)) {
if assigned >= ASSIGN_PER_TICK || d.aim.switches >= SWITCH_CAP {
continue;
}
let Some(o) = obs.iter().find(|o| {
o.confidence(now) >= Confidence::Probable
&& (o.kind.is_some() || observe::fits(d.kind, o.category))
&& o.id != d.aim.unit
&& per.get(&o.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT
}) else {
continue;
};
*per.entry(o.id).or_insert(0) += 1;
assigned += 1;
changed += 1;
d.target = o.at + d.err;
d.intent = Intent::Refresh;
d.aim = d.aim.replaced(o.id, now, o.confidence(now));
if Self::route_plannable(d) {
jobs.push(RouteJob::new(job_next, d.id, d.target, d.aim.unit, now, Intent::Refresh, Arc::clone(&known), relief.clone()));
job_next += 1;
} else {
d.route.clear();
}
}
self.job_next = job_next;
for job in jobs {
self.queue_route(job);
}
if changed > 0 {
self.refresh_applied = self.refresh_applied.saturating_add(changed);
out.messages.push(format!("Разведка противника: донесение изменило план налёта ({changed} целей)"));
}
}
/// Whether the picture holds a live contact for this unit: what the old revelation log
/// answered at a scan, now one map lookup.
pub(super) fn known_live(&self, id: u32) -> bool {
/// answered at a scan, now one map lookup. A public belief, never the unit's truth.
pub fn known_live(&self, id: u32) -> bool {
if recon::is_mark(id) {
return self.recon.live(id, self.tick);
}
@@ -625,6 +845,9 @@ impl Sim {
let knowledge = Arc::new(self.knowledge_now());
let picture = &knowledge.contacts;
let leads = &knowledge.marks;
// The candidate picks from the one merged hint list (#149); the legacy mode keeps the
// two separate lists and their old scales.
let obs = if self.smart_legacy { Vec::new() } else { knowledge.observations() };
if picture.is_empty() && leads.is_empty() {
return;
}
@@ -681,23 +904,30 @@ impl Sim {
if assigned >= ASSIGN_PER_TICK {
continue;
}
let exact = Self::fresh_target(&picture, &per_contact, d.kind, n);
// No disclosure contact to take: a recon mark whose observed role fits this drone,
// best role and freshest first, bounded per mark as any assignment is. Where both
// exist, the better observed role and fresher mark wins; a hidden unit is in neither.
let mark = Self::fresh_recon_target(&leads, &per_contact);
let (at, unit, confidence) = match (exact, mark) {
(Some(c), Some(m)) => {
let exact_rank = Self::exact_rank(&c, now);
if m.priority(now) > exact_rank {
(m.area, m.id, m.confidence(now))
} else {
(c.at, c.id, c.confidence(now))
// The candidate picks from the one merged hint list (#149): a matched mark is not a
// second target, and both channels rank on the same public scale. The legacy mode
// keeps the two separate lists and their old scales.
let (at, unit, confidence) = if self.smart_legacy {
let exact = Self::fresh_target(&picture, &per_contact, d.kind, n);
let mark = Self::fresh_recon_target(&leads, &per_contact);
match (exact, mark) {
(Some(c), Some(m)) => {
let exact_rank = Self::exact_rank(&c, now);
if m.priority(now) > exact_rank {
(m.area, m.id, m.confidence(now))
} else {
(c.at, c.id, c.confidence(now))
}
}
(Some(c), None) => (c.at, c.id, c.confidence(now)),
(None, Some(m)) => (m.area, m.id, m.confidence(now)),
(None, None) => continue,
}
} else {
match Self::fresh_observation(&obs, &per_contact, d.kind, n) {
Some(o) => (o.at, o.id, o.confidence(now)),
None => continue,
}
(Some(c), None) => (c.at, c.id, c.confidence(now)),
(None, Some(m)) => (m.area, m.id, m.confidence(now)),
(None, None) => continue,
};
*per_contact.entry(unit).or_insert(0) += 1;
assigned += 1;
@@ -737,30 +967,41 @@ impl Sim {
if d.aim.switches >= SWITCH_CAP || assigned >= ASSIGN_PER_TICK {
continue;
}
let exact = picture
.iter()
.filter(|c| !plannable || Self::can_turn_to(d, c.at))
.filter(|c| per_contact.get(&c.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.map(|c| (c.at.distance(d.pos), c.id, c.at, c.confidence(now)))
.min_by(|a, b| a.0.total_cmp(&b.0));
let mark = leads
.iter()
.filter(|m| !plannable || Self::can_turn_to(d, m.area))
.filter(|m| per_contact.get(&m.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.map(|m| (m.area.distance(d.pos), m.id, m.area, m.confidence(now), m.priority(now)))
.min_by(|a, b| b.4.cmp(&a.4).then(a.0.total_cmp(&b.0)));
// A confirmed recon mark outranks a doubtful disclosure; an exact contact of equal
// freshness is preferred, because it is a fix rather than an area.
let exact_rank = exact.map(|(_, _, _, c)| match c {
Confidence::Confirmed => 30,
Confidence::Probable => 15,
Confidence::Doubtful => 0,
});
let next = match (exact, mark) {
(Some(_), Some(m)) if m.4 > exact_rank.unwrap_or(0) + 3 => Some((m.0, m.1, m.2, m.3)),
(Some(e), _) => Some(e),
(None, Some(m)) => Some((m.0, m.1, m.2, m.3)),
(None, None) => None,
// The candidate replaces from the one merged hint list, best public rank first and
// nearest among equals (#149); the legacy mode keeps the two lists and their scales.
let next = if self.smart_legacy {
let exact = picture
.iter()
.filter(|c| !plannable || Self::can_turn_to(d, c.at))
.filter(|c| per_contact.get(&c.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.map(|c| (c.at.distance(d.pos), c.id, c.at, c.confidence(now)))
.min_by(|a, b| a.0.total_cmp(&b.0));
let mark = leads
.iter()
.filter(|m| !plannable || Self::can_turn_to(d, m.area))
.filter(|m| per_contact.get(&m.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.map(|m| (m.area.distance(d.pos), m.id, m.area, m.confidence(now), m.priority(now)))
.min_by(|a, b| b.4.cmp(&a.4).then(a.0.total_cmp(&b.0)));
// A confirmed recon mark outranks a doubtful disclosure; an exact contact of equal
// freshness is preferred, because it is a fix rather than an area.
let exact_rank = exact.map(|(_, _, _, c)| match c {
Confidence::Confirmed => 30,
Confidence::Probable => 15,
Confidence::Doubtful => 0,
});
match (exact, mark) {
(Some(_), Some(m)) if m.4 > exact_rank.unwrap_or(0) + 3 => Some((m.0, m.1, m.2, m.3)),
(Some(e), _) => Some(e),
(None, Some(m)) => Some((m.0, m.1, m.2, m.3)),
(None, None) => None,
}
} else {
obs.iter()
.filter(|o| !plannable || Self::can_turn_to(d, o.at))
.filter(|o| per_contact.get(&o.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
.map(|o| (o.at.distance(d.pos), o.id, o.at, o.confidence(now), o.rank(now)))
.min_by(|a, b| b.4.cmp(&a.4).then(a.0.total_cmp(&b.0)))
.map(|(d, id, at, c, _)| (d, id, at, c))
};
if let Some((_, unit, at, confidence)) = next {
*per_contact.entry(unit).or_insert(0) += 1;
@@ -832,6 +1073,27 @@ impl Sim {
.find(|m| per_contact.get(&m.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT)
}
/// The hint a drone not yet sent at a unit should be given (#149): one merged list, one
/// public scale. A transmitting jammer is the loudest disclosure, then (for the hunters)
/// anything that showed itself, then a round-robin over what fits — a disclosure contact
/// always fits, a recon mark only when the small policy says its category suits the kind.
fn fresh_observation(obs: &[Observation], per_contact: &HashMap<u32, usize>, kind: DroneKind, n: usize) -> Option<Observation> {
let free = |o: &&Observation| per_contact.get(&o.id).copied().unwrap_or(0) < ASSIGN_PER_CONTACT;
let jammers: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Ew && o.channel == recon::Source::Jamming).filter(free).collect();
if let Some(o) = jammers.get(n % jammers.len().max(1)) {
return Some(**o);
}
let hunters = matches!(kind, DroneKind::Lancet | DroneKind::Kh22 | DroneKind::Zircon);
if hunters {
let shown: Vec<&Observation> = obs.iter().filter(|o| o.channel != recon::Source::Flyby).filter(free).collect();
if let Some(o) = shown.get(n % shown.len().max(1)) {
return Some(**o);
}
}
let fit: Vec<&Observation> = obs.iter().filter(|o| o.kind.is_some() || observe::fits(kind, o.category)).filter(free).collect();
fit.get(n % fit.len().max(1)).map(|o| **o)
}
/// Whether a fresh disclosure is worth replacing this drone's aim: a contact observed after the
/// aim was chosen, trusted (not `Doubtful`), clearly better placed or better believed, and the
/// throttle (hold time, switch cap) allows it (#127). A route change costs the planner a new
@@ -1193,6 +1455,27 @@ pub struct PendingReport {
pub reason: &'static str,
}
/// One merged public hint as the diagnostic reports it (#149): the one scale the planner ranks
/// and prices by, and whether a second channel agreed by public features (a belief, not a fact).
#[derive(Clone, Debug, PartialEq)]
pub struct ObservationReport {
pub id: u32,
pub at: DVec3,
pub radius: f64,
/// "flyby", "emission", "jamming" or "launch".
pub channel: &'static str,
pub age: u64,
pub confidence: Confidence,
pub category: &'static str,
pub role: Option<&'static str>,
/// The identified type of a disclosure contact; `None` for a recon mark's area.
pub kind: Option<&'static str>,
pub quality: &'static str,
/// A second public hint matched by area and category. Never a hidden truth.
pub matched: bool,
pub rank: u8,
}
/// The enemy's whole picture at one tick: what it knows and what it assumes, structured for
/// diagnostics (#127). No truth anywhere in it — a unit the picture got wrong is reported wrong.
#[derive(Clone, Debug, PartialEq)]
@@ -1209,6 +1492,14 @@ pub struct EnemyPictureReport {
pub recon: Vec<ReconReport>,
/// The recon flights still out.
pub recon_sorties: Vec<ReconSortieReport>,
/// The one merged hint list the candidate planner ranks and prices by (#149).
pub observations: Vec<ObservationReport>,
/// The bearing picker's last decision and its typed reason (#149).
pub bearing: BearingReport,
/// Whether a bounded refresh of the unreleased portion is still waiting for a report (#149).
pub refresh_waiting: bool,
/// Aims the refresh has re-chosen so far (#149).
pub refresh_applied: u32,
}
impl Sim {
@@ -1326,7 +1617,38 @@ impl Sim {
report_in: s.report_at.map(|t| t.saturating_sub(now)),
})
.collect();
EnemyPictureReport { now, contacts, aims, pending, work_per_tick: raid::WORK_PER_TICK, recon, recon_sorties }
let observations = self
.knowledge_now()
.observations()
.into_iter()
.map(|o| ObservationReport {
id: o.id,
at: o.at,
radius: o.radius,
channel: o.channel.name(),
age: o.age(now),
confidence: o.confidence(now),
category: o.category.name(),
role: o.role.map(|r| r.key()),
kind: o.kind.map(|k| k.spec().key),
quality: o.quality.name(),
matched: o.matched,
rank: o.rank(now),
})
.collect();
EnemyPictureReport {
now,
contacts,
aims,
pending,
work_per_tick: raid::WORK_PER_TICK,
recon,
recon_sorties,
observations,
bearing: self.bearing,
refresh_waiting: self.refresh.is_some(),
refresh_applied: self.refresh_applied,
}
}
/// What the planner makes of a contact, in words for the diagnostic (#127).
+31 -1
View File
@@ -25,10 +25,12 @@ pub mod record;
mod sight;
mod terrain;
mod ew;
mod observe;
mod optical;
mod recon;
mod durable;
pub use ew::{AimReport, Confidence, ContactReport, EnemyPictureReport, Intent, PendingReport, ReconReport, ReconSortieReport};
pub use ew::{AimReport, BearingReason, BearingReport, Confidence, ContactReport, EnemyPictureReport, Intent, ObservationReport, PendingReport, ReconReport, ReconSortieReport};
pub use observe::Observation;
pub use recon::{Category, Mark, Quality, Source, is_drone_id, priority_parts};
pub mod lights;
mod logistics;
@@ -45,6 +47,8 @@ mod balance;
mod regress;
#[cfg(test)]
mod sensor_tests;
#[cfg(test)]
mod smart_tests;
pub use ew::EW_RADIUS;
pub use damage::{Comps, Part, PartState};
pub use sight::{AirPicture, Ident, LowSensor, Track, RIM_RAYS};
@@ -1494,6 +1498,16 @@ pub struct Sim {
intel: ew::Intel,
/// Reconnaissance flights and the partial picture they radioed home (#135).
recon: recon::Recon,
/// The smart enemy runs the legacy picks (#149's comparison runner): the two separate hint
/// lists and their old scales, the lifetime bearing tally with its fixed share, no mark
/// pricing and no refresh of the unreleased portion. The light modes never read it.
pub smart_legacy: bool,
/// The bounded refresh of the last smart raid's unreleased portion (#149), while it waits.
refresh: Option<ew::Refresh>,
/// Aims the refresh has re-chosen (#149; diagnostics).
refresh_applied: u32,
/// The bearing picker's last decision and its typed reason (#149).
bearing: ew::BearingReport,
/// Night: guns need light (the mod sets it from the game's clock).
pub night: bool,
/// The long fires at crash and impact points (#52).
@@ -1572,6 +1586,10 @@ impl Sim {
tally: record::Tally::default(),
intel: ew::Intel::default(),
recon: recon::Recon::default(),
smart_legacy: false,
refresh: None,
refresh_applied: 0,
bearing: ew::BearingReport::default(),
night: false,
fires: fires::Fires::default(),
day_time: None,
@@ -1593,6 +1611,16 @@ impl Sim {
self.next * PARTS
}
/// The bearing picker's last decision and its typed reason (#149; diagnostics).
pub fn bearing_report(&self) -> ew::BearingReport {
self.bearing
}
/// Aims the bounded refresh of the unreleased portion has re-chosen (#149; diagnostics).
pub fn refresh_applied(&self) -> u32 {
self.refresh_applied
}
/// What a system's camera follows: its guns' or missiles' target, else what its missiles in
/// flight are after.
pub fn watched(&self, sam: &Sam) -> Option<&Drone> {
@@ -1685,6 +1713,7 @@ impl Sim {
self.retargets.clear();
self.known_relief = None;
self.recon.clear_sorties();
self.refresh = None;
self.wave = None;
// Ammunition still to cook off, flares in the sky.
self.later.clear();
@@ -1728,6 +1757,7 @@ impl Sim {
self.tick += 1;
self.plan_step(Some(&mut *ground), out);
self.adapt();
self.step_refresh(out);
self.step_settling(ground);
self.release_queue(ground, out);
self.begin_recording_if_active();
+268
View File
@@ -0,0 +1,268 @@
//! The planner's one public observation (#149): a disclosure `Contact` and a recon `Mark` are
//! two channels hinting at the same game objects, on two different scales. This module projects
//! both into a single [`Observation`] — an area, a channel, an age, a confidence and the public
//! game features — and matches them by those public features alone: a mark whose area holds a
//! contact's fix and whose observed category agrees is the same hint, not a second target.
//!
//! A match is a belief, never a fact: it is made only on an exact public category agreement and
//! area overlap, it is flagged (`matched`), and it invents nothing — the contact keeps the kind
//! and place it was observed with, the mark only adds what it publicly saw (a refined radar role,
//! a fresher look). A coarse `Unknown` mark or a contradicting category is *not* matched: it stays
//! a separate hint. The observer's truth map and the units' real ids play no part here.
use super::*;
/// A contact fix this far inside a mark's area (on top of its radius) reads as the same public
/// hint. The fix is exact, the area is coarse: the slack is the cell jitter a report carries.
const MATCH_SLACK: f64 = 8.0;
/// One public hint about one game object, from either channel (#149). There is no health,
/// magazine, link, hidden switch or true place in it: `kind` is `Some` only for a disclosure
/// contact, whose type was identified at the observation; a mark carries its coarse category.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Observation {
/// The hint's public id: a contact's id, or a mark's synthetic one. Never a matched unit's truth.
pub id: u32,
/// The best public place: a contact's fix, or a mark's area centre.
pub at: DVec3,
/// 0 for an exact fix; the area's radius for a mark.
pub radius: f64,
/// The channel that showed it last: flyby, emission, jamming or launch.
pub channel: recon::Source,
/// The tick of the observation this hint rests on.
pub observed: u64,
pub category: recon::Category,
/// A radar's role, once a refined look told it.
pub role: Option<battery::RadarRole>,
/// The type identified at a disclosure observation; `None` for a recon mark.
pub kind: Option<SamKind>,
pub quality: recon::Quality,
/// A second public hint agreed by area and category. A belief for the diagnostic, not a fact.
pub matched: bool,
}
impl Observation {
pub fn age(&self, now: u64) -> u64 {
now.saturating_sub(self.observed)
}
pub fn confidence(&self, now: u64) -> Confidence {
ew::confidence_for_age(self.age(now))
}
/// An exact disclosure fix, rather than a coarse area.
pub fn exact(&self) -> bool {
self.radius == 0.0
}
pub fn live(&self, now: u64) -> bool {
self.age(now) < ew::CONTACT_TTL
}
/// The one ranking scale both channels share (#149): the mark's priority parts (freshness,
/// quality, observed role) plus a small premium for being a fix rather than an area.
pub fn rank(&self, now: u64) -> u8 {
let (f, q, r) = recon::priority_parts(self.confidence(now), self.quality, self.category, self.role);
f * 4 + q * 3 + r + u8::from(self.exact()) * 3
}
}
/// The disclosure channel in the one scale the marks already use.
pub(super) fn channel_of(seen: ew::Seen) -> recon::Source {
match seen {
ew::Seen::Launch => recon::Source::Launch,
ew::Seen::Emission => recon::Source::Emission,
ew::Seen::Jamming => recon::Source::Jamming,
}
}
/// Projects contacts and marks into one list of public hints, best first. A mark is matched to a
/// contact only by public features (area overlap and an exact category agreement); a matched mark
/// is consumed — the object is one hint, priced and assigned once. Unmatched marks stand as areas.
pub(super) fn merge(contacts: &[ew::Contact], marks: &[recon::Mark], now: u64) -> Vec<Observation> {
let mut out: Vec<Observation> = contacts
.iter()
.filter(|c| c.live(now))
.map(|c| Observation {
id: c.id,
at: c.at,
radius: 0.0,
channel: channel_of(c.seen),
observed: c.tick,
category: recon::Category::of(c.kind),
role: None,
kind: Some(c.kind),
quality: recon::Quality::Refined,
matched: false,
})
.collect();
let mut areas = Vec::new();
for m in marks.iter().filter(|m| m.live(now)) {
let hit = out.iter_mut().find(|o| {
o.kind.is_some()
&& m.category != recon::Category::Unknown
&& m.category == o.category
&& (m.role.is_none() || o.category == recon::Category::Radar)
&& horizontal(o.at - m.area).length() <= m.radius + MATCH_SLACK
});
match hit {
Some(o) => {
// The match is public evidence, not truth: the fresher look and the refined role
// are what the mark itself saw; the contact's kind and fix are never rewritten.
o.matched = true;
if m.observed > o.observed {
o.observed = m.observed;
o.channel = m.source;
}
if o.category == recon::Category::Radar && m.role.is_some() {
o.role = m.role;
}
}
None => areas.push(Observation {
id: m.id,
at: m.area,
radius: m.radius,
channel: m.source,
observed: m.observed,
category: m.category,
role: m.role,
kind: None,
quality: m.quality,
matched: false,
}),
}
}
out.extend(areas);
out.sort_by(|a, b| b.rank(now).cmp(&a.rank(now)).then(b.observed.cmp(&a.observed)).then(a.id.cmp(&b.id)));
out
}
/// The small game policy (#149): which observed categories a kind is worth turning onto. One
/// place for the fit both the plan's picks and the adaptive assignments read — no hidden state,
/// only the public category and the kind's published role.
pub(super) fn fits(kind: DroneKind, category: recon::Category) -> bool {
use recon::Category as C;
match kind {
DroneKind::Lancet => matches!(category, C::Gun | C::Launcher | C::Ew),
DroneKind::Kh22 | DroneKind::Zircon => matches!(category, C::Radar | C::Launcher | C::Ew),
DroneKind::Iskander | DroneKind::Kinzhal => matches!(category, C::Radar | C::Launcher),
DroneKind::Shahed | DroneKind::Geran3 => matches!(category, C::Radar | C::Launcher | C::Gun | C::Ew),
_ => false,
}
}
/// The public worst-case envelope of a category: the furthest missile reach and gun range any
/// published kind of that category has, for this drone at this height. What a mark's area may
/// hold is priced by the catalog, never by a hidden unit's actual load (#149).
pub(super) fn category_envelope(category: recon::Category) -> (f64, f64, f64) {
let mut lo = f64::INFINITY;
let mut hi = 0.0f64;
let mut gun = 0.0f64;
for k in SamKind::ALL {
if recon::Category::of(k) != category {
continue;
}
let sp = k.spec();
if let Some(m) = &sp.missile {
lo = lo.min(m.min);
hi = hi.max(m.max);
}
if let Some(g) = &sp.gun {
gun = gun.max(g.range);
}
}
(lo.min(hi), hi, gun)
}
/// The published reach of the strongest radar kind, for a mark that only says "a radar is here".
pub(super) fn radar_envelope(drone: DroneKind, height: f64) -> f64 {
SamKind::ALL
.into_iter()
.filter(|k| recon::Category::of(*k) == recon::Category::Radar)
.map(|k| ew::published_reach(k, drone, height))
.fold(0.0, f64::max)
}
#[cfg(test)]
mod tests {
use super::*;
fn contact(id: u32, kind: SamKind, at: DVec3, tick: u64) -> ew::Contact {
ew::Contact { id, kind, at, tick, seen: ew::Seen::Emission, emission: Some(tick), destroyed: None, launches: 0 }
}
fn mark(id: u32, at: DVec3, category: recon::Category, observed: u64) -> recon::Mark {
recon::Mark {
id,
area: at,
radius: recon::COARSE_AREA,
category,
role: None,
source: recon::Source::Flyby,
observed,
reported: observed,
quality: recon::Quality::Coarse,
looks: 1,
}
}
// #149: one object, two channels, one hint. A mark whose area holds the contact's fix and
// whose category agrees is matched and consumed — not a second target. The match reads only
// public features: two marks of different hidden truths but the same public area/category
// both fold into the one contact.
#[test]
fn a_matching_mark_is_one_hint_not_two() {
let at = DVec3::new(100.0, 70.0, 0.0);
let c = contact(16, SamKind::Radar, at, 100);
let m1 = mark(recon::ID_BASE + 1, at + DVec3::new(20.0, 0.0, 0.0), recon::Category::Radar, 120);
let m2 = mark(recon::ID_BASE + 2, at + DVec3::new(-30.0, 0.0, 10.0), recon::Category::Radar, 130);
let obs = merge(&[c], &[m1, m2], 200);
assert_eq!(obs.len(), 1, "the same public object stayed two hints");
assert!(obs[0].matched && obs[0].exact() && obs[0].kind == Some(SamKind::Radar));
assert_eq!(obs[0].observed, 130, "the fresher public look was not taken");
assert_eq!(obs[0].id, 16, "the hint kept the mark's synthetic id over the contact's");
}
// #149: an unconfirmed match is not a fact. A coarse Unknown mark, a contradicting category,
// or an area that does not hold the fix stays a separate hint — nothing is merged on a guess.
#[test]
fn an_unconfirmed_match_stays_separate() {
let at = DVec3::new(100.0, 70.0, 0.0);
let c = contact(16, SamKind::Radar, at, 100);
let unknown = mark(recon::ID_BASE + 1, at, recon::Category::Unknown, 120);
let wrong = mark(recon::ID_BASE + 2, at, recon::Category::Launcher, 120);
let far = mark(recon::ID_BASE + 3, at + DVec3::new(400.0, 0.0, 0.0), recon::Category::Radar, 120);
let obs = merge(&[c], &[unknown, wrong, far], 200);
assert_eq!(obs.len(), 4, "a weak match was treated as a fact");
assert!(obs.iter().filter(|o| o.kind.is_some()).all(|o| !o.matched));
// A refined role is public only for a radar; a launcher mark never lends one.
let mut radar = mark(recon::ID_BASE + 4, at, recon::Category::Radar, 140);
radar.quality = recon::Quality::Refined;
radar.role = Some(battery::RadarRole::Engagement);
let obs = merge(&[c], &[radar], 200);
assert_eq!(obs.len(), 1);
assert_eq!(obs[0].role, Some(battery::RadarRole::Engagement));
}
// #149: one scale. A fresh confirmed fix outranks an old doubtful area; a refined big-role
// mark outranks a coarse modest one of the same age; the order never reads an id or a truth.
#[test]
fn the_rank_is_one_public_scale() {
let fresh = contact(16, SamKind::Radar, DVec3::ZERO, 190);
let old = mark(recon::ID_BASE + 1, DVec3::X * 500.0, recon::Category::Launcher, 0);
let obs = merge(&[fresh], &[old], 200);
assert_eq!(obs[0].id, 16, "a fresh fix did not lead an old area");
let mut big = mark(recon::ID_BASE + 2, DVec3::X * 900.0, recon::Category::Radar, 190);
big.quality = recon::Quality::Refined;
big.role = Some(battery::RadarRole::Engagement);
let modest = mark(recon::ID_BASE + 3, DVec3::X * 1300.0, recon::Category::Radar, 190);
let obs = merge(&[], &[modest, big], 200);
assert_eq!(obs[0].id, big.id, "the bigger observed role did not lead");
assert!(obs[0].rank(200) > obs[1].rank(200));
}
// #149: the policy fit is the public category, the same for the plan and the adaptive picks.
#[test]
fn the_fit_is_the_public_category() {
assert!(fits(DroneKind::Lancet, recon::Category::Gun));
assert!(!fits(DroneKind::Lancet, recon::Category::Radar));
assert!(fits(DroneKind::Kh22, recon::Category::Radar));
assert!(!fits(DroneKind::Iskander, recon::Category::Gun));
assert!(!fits(DroneKind::Gerbera, recon::Category::Launcher));
}
}
+127 -18
View File
@@ -519,6 +519,13 @@ impl Sim {
if plan.smart && !plan.heights.is_empty() {
self.known_relief = Some(std::sync::Arc::new(ew::KnownRelief::new(plan.grid, std::mem::take(&mut plan.heights))));
}
// The bounded refresh moment for the unreleased portion (#149): a recon flight is still
// out, so a report may arrive while the drones wait to launch, and the plan's own picks
// may be re-aimed once on it. The deadline is absolute and the launches keep their times
// — no report never pauses the raid.
if plan.smart && !self.smart_legacy && !self.recon.sorties.is_empty() {
self.refresh = Some(ew::Refresh { deadline: self.tick + ew::REFRESH_WINDOW, reports: self.recon.reports });
}
self.wave = Some(WaveStats {
kills: self.kills,
hits: self.hits,
@@ -604,24 +611,33 @@ impl Sim {
/// gets two or three, the fast strikers first, and all together no more than about a quarter of the raid.
/// Only contacts the picture still trusts: a doubtful one (aged, never re-seen) is not worth a missile.
pub(super) fn radar_strikes(&self, kinds: &[(DroneKind, u32)], picture: &[ew::Contact], leads: &[recon::Mark]) -> Vec<Option<(DVec3, u32)>> {
// Exact disclosure contacts and recon marks of radars, best first. The order is the
// observed role, freshness and quality -- never the id: a hidden station has no id,
// and a big observed radar is worth more than a modest one (#135). Both lists are the
// order's own knowledge version, not a later picture (#146).
// Radars the picture trusts, best first. The candidate ranks the one merged hint list on
// the single public scale (#149): a mark matched to a contact is not a second radar. The
// legacy mode keeps the two chains and their old scales. The order is the observed role,
// freshness and quality -- never the id (#135). Both lists are the order's own knowledge
// version, not a later picture (#146).
let now = self.tick;
let mut radars: Vec<(u8, u64, u32, DVec3)> = picture
.iter()
.filter(|c| c.kind == SamKind::Radar && c.confidence(now) >= ew::Confidence::Probable)
.map(|c| {
let seen = match c.confidence(now) {
ew::Confidence::Confirmed => 4,
ew::Confidence::Probable => 2,
ew::Confidence::Doubtful => 0,
};
(seen * 10 + 3, c.tick, c.id, c.at)
})
.chain(leads.iter().copied().filter(|m| m.category == recon::Category::Radar && m.confidence(now) >= ew::Confidence::Probable).map(|m| (m.priority(now), m.observed, m.id, m.area)))
.collect();
let mut radars: Vec<(u8, u64, u32, DVec3)> = if self.smart_legacy {
picture
.iter()
.filter(|c| c.kind == SamKind::Radar && c.confidence(now) >= ew::Confidence::Probable)
.map(|c| {
let seen = match c.confidence(now) {
ew::Confidence::Confirmed => 4,
ew::Confidence::Probable => 2,
ew::Confidence::Doubtful => 0,
};
(seen * 10 + 3, c.tick, c.id, c.at)
})
.chain(leads.iter().copied().filter(|m| m.category == recon::Category::Radar && m.confidence(now) >= ew::Confidence::Probable).map(|m| (m.priority(now), m.observed, m.id, m.area)))
.collect()
} else {
observe::merge(picture, leads, now)
.into_iter()
.filter(|o| o.category == recon::Category::Radar && o.confidence(now) >= ew::Confidence::Probable)
.map(|o| (o.rank(now), o.observed, o.id, o.at))
.collect()
};
radars.sort_by(|a, b| b.0.cmp(&a.0).then(b.1.cmp(&a.1)).then(a.2.cmp(&b.2)));
let radars: Vec<(u32, DVec3)> = radars.into_iter().map(|(_, _, id, at)| (id, at)).collect();
let flat: Vec<DroneKind> = kinds.iter().flat_map(|&(k, n)| std::iter::repeat_n(k, n as usize)).collect();
@@ -660,7 +676,42 @@ impl Sim {
if aim == Aim::ObjectsAndSams {
return if roll < 0.33 { pick(picture, r).map_or((object, None), |(p, id)| (p, Some(id))) } else { (object, None) };
}
// Smart: each kind at what it is good against; what gave itself away first (a jamming
// The candidate picks from the one merged hint list (#149): a matched mark is not a
// second target, and the fit is the small public policy, not a per-kind guess.
if !self.smart_legacy {
let obs = observe::merge(picture, leads, self.tick);
let pick_o = |list: &[&Observation], r: f64| -> Option<(DVec3, u32)> {
let o = list.get((r * list.len() as f64) as usize)?;
Some((o.at, o.id))
};
let jammers: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Ew && o.channel == recon::Source::Jamming).collect();
if matches!(kind, DroneKind::Lancet | DroneKind::Kh22) && !jammers.is_empty() && roll < 0.6 {
if let Some((at, id)) = pick_o(&jammers, r) {
return (at, Some(id));
}
}
let guns: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Gun || o.kind.is_some_and(|k| k.armed() && k.range() <= 300.0)).collect();
let long: Vec<&Observation> = obs.iter().filter(|o| o.category == recon::Category::Radar || o.kind.is_some_and(|k| k.range() >= 450.0)).collect();
let all: Vec<&Observation> = obs.iter().collect();
let choice = match kind {
DroneKind::Lancet if roll < 0.75 => pick_o(&guns, r).or_else(|| pick_o(&all, r)),
DroneKind::Kh22 | DroneKind::Zircon if roll < 0.45 => pick_o(&long, r),
DroneKind::Iskander | DroneKind::Kinzhal if roll < 0.3 => pick_o(&long, r),
DroneKind::Shahed | DroneKind::Geran3 if roll < 0.2 => pick_o(&all, r),
_ => None,
};
if let Some((at, id)) = choice {
return (at, Some(id));
}
// Nothing the kind's usual preference picked: an unmerged mark whose observed
// category fits is the next best reason to turn a strike off the object.
let fits: Vec<&Observation> = obs.iter().filter(|o| o.kind.is_none() && observe::fits(kind, o.category)).collect();
if let Some((at, id)) = pick_o(&fits, r) {
return (at, Some(id));
}
return (object, None);
}
// Legacy smart: each kind at what it is good against; what gave itself away first (a jamming
// station, a radar, a system that fired).
let known_ew: Vec<ew::Contact> = picture.iter().copied().filter(|c| c.kind == SamKind::Ew).collect();
if matches!(kind, DroneKind::Lancet | DroneKind::Kh22) && !known_ew.is_empty() && roll < 0.6 {
@@ -746,6 +797,17 @@ impl Sim {
.filter(|d| d.kind == SamKind::Radar && d.id != c.id && d.at.distance(pos) <= sight::LINK)
.map(|d| ew::published_reach(d.kind, kind, height))
.fold(0.0, f64::max);
// A trusted radar mark near the observed place feeds the network too (#149): the
// strongest published radar reach, since the mark does not name the kind.
let net = if self.smart_legacy {
net
} else {
knowledge.marks
.iter()
.filter(|m| m.category == recon::Category::Radar && m.confidence(now) >= ew::Confidence::Probable && m.area.distance(pos) <= sight::LINK)
.map(|_| observe::radar_envelope(kind, height))
.fold(net, f64::max)
};
let (hi, gun) = (hi.min(own.max(net)), gun.min(own));
let far = hi.max(gun);
// Only the cells round it.
@@ -768,6 +830,53 @@ impl Sim {
}
}
}
// The marks the contacts do not already stand for (#149): an area is priced by its public
// category's published envelope, weighted by the confidence the age alone gives. A mark
// matched to a contact is one hint and was priced through the contact above.
if !self.smart_legacy {
for o in knowledge.observations().into_iter().filter(|o| o.kind.is_none() && o.confidence(now) >= ew::Confidence::Probable) {
let scale: f32 = if o.confidence(now) == ew::Confidence::Confirmed { 1.0 } else { 0.5 };
let pos = o.at;
match o.category {
recon::Category::Ew if kind.jammable() => {
let reach = ew::EW_RADIUS + o.radius;
let (ci, cj) = grid.index(pos);
let r = (reach / grid.cell).ceil() as i32;
for i in (ci - r).max(0)..=(ci + r).min(n - 1) {
for j in (cj - r).max(0)..=(cj + r).min(n - 1) {
cost += 1;
if horizontal(grid.centre((i, j), pos.y) - pos).length() < reach {
prices[(i * n + j) as usize] += 12.0 * scale;
}
}
}
}
recon::Category::Launcher | recon::Category::Gun => {
let (lo, hi, gun) = observe::category_envelope(o.category);
let far = hi.max(gun) + o.radius;
let (ci, cj) = grid.index(pos);
let r = (far / grid.cell).ceil() as i32 + 1;
for i in (ci - r).max(0)..=(ci + r).min(n - 1) {
for j in (cj - r).max(0)..=(cj + r).min(n - 1) {
cost += 1;
let ground = land.map(|l| l[(i * n + j) as usize]).filter(|g| g.is_finite());
let p = grid.centre((i, j), ground.map_or(pos.y + height, |g| f64::from(g) + height));
let d = horizontal(p - pos).length();
if d > far {
continue;
}
let missile = (lo..hi).contains(&d);
if !(missile || d < gun) {
continue;
}
prices[(i * n + j) as usize] += (if missile { 30.0 } else { 18.0 }) * scale;
}
}
}
_ => {}
}
}
}
(prices, cost)
}
+3 -1
View File
@@ -297,7 +297,9 @@ fn wall_relief() -> std::sync::Arc<super::ew::KnownRelief> {
for j in 0..g.size {
let x = g.min.x + (f64::from(i) + 0.5) * g.cell;
let z = g.min.z + (f64::from(j) + 0.5) * g.cell;
if (x + 1000.0).abs() < 80.0 && z.abs() < 420.0 {
// The wall spans every approach lane: whichever drone the adaptive tick leaves last,
// its east-west route crosses the ridge, so the two relief versions must differ (#149).
if (x + 1000.0).abs() < 80.0 && z.abs() < 2000.0 {
h[(i * g.size + j) as usize] = 1000.0;
}
}
+312
View File
@@ -0,0 +1,312 @@
//! Smart v2 (#149): the merged public picture, one knowledge version per order, the bounded
//! refresh of the unreleased portion, and the bearing window — and the metamorphic guarantee
//! that a hidden permutation nothing observed changes no decision.
use super::*;
use super::sites::testland::{Land, serve};
fn grid() -> raid::Grid {
raid::Grid { min: DVec3::new(-800.0, 0.0, -800.0), cell: 16.0, size: 100 }
}
fn mark(id: u32, at: DVec3, category: recon::Category, observed: u64) -> recon::Mark {
recon::Mark {
id,
area: at,
radius: recon::COARSE_AREA,
category,
role: None,
source: recon::Source::Flyby,
observed,
reported: observed,
quality: recon::Quality::Coarse,
looks: 1,
}
}
fn contact(id: u32, kind: SamKind, at: DVec3, tick: u64) -> ew::Contact {
ew::Contact { id, kind, at, tick, seen: ew::Seen::Emission, emission: Some(tick), destroyed: None, launches: 0 }
}
fn order() -> RaidOrder {
RaidOrder { kinds: vec![(DroneKind::Shahed, 4), (DroneKind::Kh22, 2)], approach: Approach::Sector, dist: 900.0, aim: Aim::Smart }
}
// #149: the metamorphic guarantee. Two worlds with the same seed and the same observed radar,
// whose hidden forces are a permutation of one another (kinds swapped between places), order
// the same recon flight, the same aims and intents, and the same prices — nothing unobserved
// leaks into a decision.
#[test]
fn a_hidden_permutation_changes_nothing_before_observation() {
let object = DVec3::new(0.0, 70.0, 0.0);
let build = |perm: bool| {
let mut sim = Sim::new(149);
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::new(150.0, 70.0, -80.0), 0.0);
sim.intel.observe(&radar, 0, ew::Seen::Emission);
sim.sams.push(radar);
let spots = [DVec3::new(-200.0, 70.0, 100.0), DVec3::new(300.0, 70.0, 200.0), DVec3::new(-50.0, 70.0, -300.0)];
let kinds = if perm { [SamKind::Pantsir, SamKind::S400, SamKind::Tor] } else { [SamKind::S400, SamKind::Tor, SamKind::Pantsir] };
for (k, p) in kinds.into_iter().zip(spots) {
let id = sim.id();
sim.sams.push(Sam::new(id, k, p, 0.0));
}
sim.targets.push(object);
sim.target_health.push(100.0);
let mut out = Out::default();
sim.order_raid(&order(), &[object], &mut out);
let flight: Vec<_> = sim.recon.sorties.iter().map(|s| s.zones.iter().map(|z| (z.center, z.radius)).collect::<Vec<_>>()).collect();
let aims = sim.planned_aims();
let intents = sim.planned_intents();
let (prices, _) = sim.price_grid(&grid(), DroneKind::Kh101);
(flight, aims, intents, prices)
};
assert_eq!(build(false), build(true), "a hidden permutation changed the flight, the plan or the prices");
}
// #149: the same guarantee after a look. Once a radar is observed, permuting only the units
// nothing saw changes neither the structured picture nor the prices.
#[test]
fn a_hidden_permutation_changes_nothing_after_observation() {
let build = |perm: bool| {
let mut sim = Sim::new(149);
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::new(150.0, 70.0, -80.0), 0.0);
sim.intel.observe(&radar, 0, ew::Seen::Emission);
sim.sams.push(radar);
let spots = [DVec3::new(-200.0, 70.0, 100.0), DVec3::new(300.0, 70.0, 200.0)];
let kinds = if perm { [SamKind::S400, SamKind::Pantsir] } else { [SamKind::Pantsir, SamKind::S400] };
for (k, p) in kinds.into_iter().zip(spots) {
let id = sim.id();
sim.sams.push(Sam::new(id, k, p, 0.0));
}
sim.tick = 100;
let (prices, _) = sim.price_grid(&grid(), DroneKind::Kh101);
(sim.enemy_picture(), prices)
};
assert_eq!(build(false), build(true), "a hidden permutation moved the picture or the prices after a look");
}
// #149: price_grid_known accounts for marks. A fresh probable mark raises the cells its public
// category covers; a doubtful one prices nothing; a mark matched to a contact is priced once,
// exactly as the contact alone. The legacy mode prices contacts only.
#[test]
fn a_fresh_mark_prices_the_map_and_a_doubtful_one_does_not() {
let mut sim = Sim::new(149);
let g = grid();
let m = mark(recon::ID_BASE + 1, DVec3::new(0.0, 70.0, 0.0), recon::Category::Launcher, 0);
let fresh = ew::KnowledgeSnapshot::new(100, Vec::new(), vec![m]);
let (prices, _) = sim.price_grid_known(&g, DroneKind::Kh101, None, &fresh);
assert!(prices.iter().any(|p| *p > 1.0), "a fresh launcher mark priced nothing");
let old = ew::KnowledgeSnapshot::new(4000, Vec::new(), vec![m]);
let (prices, _) = sim.price_grid_known(&g, DroneKind::Kh101, None, &old);
assert!(prices.iter().all(|p| *p == 1.0), "a doubtful mark was priced");
// Merged into a contact of the same public category: one hint, priced once.
let c = contact(16, SamKind::S400, m.area, 100);
let merged = ew::KnowledgeSnapshot::new(100, vec![c], vec![m]);
let only = ew::KnowledgeSnapshot::new(100, vec![c], Vec::new());
assert_eq!(
sim.price_grid_known(&g, DroneKind::Kh101, None, &merged).0,
sim.price_grid_known(&g, DroneKind::Kh101, None, &only).0,
"a matched mark was priced twice"
);
// The legacy mode does not price marks at all.
sim.smart_legacy = true;
let (prices, _) = sim.price_grid_known(&g, DroneKind::Kh101, None, &fresh);
assert!(prices.iter().all(|p| *p == 1.0), "the legacy mode priced a mark");
}
// #146/#149: one order prices every kind over the snapshot its targets were chosen from. A
// contact disclosed while the plan is still being worked out changes neither mode's routes:
// the #146 versioning is preserved for the candidate and the legacy picker alike.
#[test]
fn one_order_prices_every_kind_over_its_own_snapshot() {
let object = DVec3::new(0.0, 70.0, 300.0);
let build = |legacy: bool, disclose: bool| {
let mut sim = Sim::new(149);
sim.smart_legacy = legacy;
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::new(600.0, 70.0, -600.0), 0.0);
sim.intel.observe(&radar, 0, ew::Seen::Emission);
sim.sams.push(radar);
sim.targets.push(object);
sim.target_health.push(100.0);
let mut ground = Ground::default();
let land = Land(|_, _| 64);
let mut out = Out::default();
for _ in 0..20 {
serve(&mut ground, &land, sim.tick);
sim.step(&mut ground, None, &mut out);
}
let order = RaidOrder { kinds: vec![(DroneKind::Kh101, 6), (DroneKind::Shahed, 8)], approach: Approach::Sector, dist: 600.0, aim: Aim::Smart };
sim.order_raid(&order, &[object], &mut out);
if disclose {
// A jamming station gives itself away at the objective while the plan waits for its
// land: every satellite-nav kind prices it, so the live picture bends the routes.
let id = sim.id();
let threat = Sam::new(id, SamKind::Ew, object, 0.0);
sim.intel.observe(&threat, sim.tick, ew::Seen::Jamming);
sim.sams.push(threat);
}
// Work the plan alone (no adaptive ticks): the queue's routes are the plan's own.
while sim.planning() {
serve(&mut ground, &land, sim.tick);
sim.tick += 1;
sim.plan_step(Some(&mut ground), &mut out);
}
sim.queue.iter().map(|(_, d)| (d.id, d.route.clone())).collect::<Vec<_>>()
};
assert_eq!(build(false, false), build(false, true), "the candidate mixed two knowledge versions in one order");
assert_eq!(build(true, false), build(true, true), "the legacy mode lost the #146 one-version pricing");
}
// #149: a report arriving while the raid's drones still wait re-aims the plan's own picks once,
// on a fresh snapshot, within the switch cap — and then the refresh is spent.
#[test]
fn a_report_refreshes_the_unreleased_portion_once() {
let object = DVec3::new(0.0, 70.0, 0.0);
let mut sim = Sim::new(149);
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::S400, object + DVec3::new(20.0, 0.0, 10.0), 0.0));
sim.targets.push(object);
sim.target_health.push(100.0);
let mut ground = Ground::default();
let land = Land(|_, _| 64);
let mut out = Out::default();
for _ in 0..20 {
serve(&mut ground, &land, sim.tick);
sim.step(&mut ground, None, &mut out);
}
sim.order_raid(&order(), &[object], &mut out);
// Force the first sortie's look so a report is pending, then finish the plan: the refresh
// moment is armed only because a report is actually on its way.
let s = sim.recon.sorties.first().expect("no recon sortie").clone();
let d = sim.drones.iter_mut().find(|d| d.id == s.drone).expect("the sortie has no aircraft");
d.pos = s.zones[s.next].center + DVec3::Y * 40.0;
sim.tick += 1;
sim.step_recon(&mut out);
let report_at = sim.recon.sorties.first().unwrap().report_at.expect("no pending report");
while sim.planning() {
serve(&mut ground, &land, sim.tick);
sim.tick += 1;
sim.plan_step(Some(&mut ground), &mut out);
}
assert!(sim.refresh.is_some(), "a pending report did not arm the bounded refresh");
// The report arrives: the mark is in the picture.
sim.tick = report_at;
sim.step_recon(&mut out);
assert!(sim.recon.reports > 0);
let m = *sim.recon.marks.values().next().expect("the report left no mark");
// One drone is past the switch cap: it keeps its aim.
sim.queue[0].1.aim.switches = ew::SWITCH_CAP;
let capped = sim.queue[0].1.id;
sim.step_refresh(&mut out);
assert!(sim.refresh.is_none(), "the refresh was not spent");
assert!(sim.refresh_applied > 0, "the report re-aimed nobody");
assert!(sim.queue.iter().any(|(_, d)| d.intent == ew::Intent::Refresh && d.aim.unit == m.id), "no drone was refreshed onto the mark");
assert!(sim.queue.iter().find(|(_, d)| d.id == capped).unwrap().1.intent != ew::Intent::Refresh, "a drone past the cap was refreshed");
// Spent: a second call changes nothing.
let applied = sim.refresh_applied;
sim.step_refresh(&mut out);
assert_eq!(sim.refresh_applied, applied);
}
// #149: no report never pauses the raid. Past the deadline the refresh is dropped and the
// launches keep the times the plan gave them.
#[test]
fn no_report_never_pauses_the_raid() {
let object = DVec3::new(0.0, 70.0, 0.0);
let mut sim = Sim::new(149);
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::S400, object + DVec3::new(20.0, 0.0, 10.0), 0.0));
sim.targets.push(object);
sim.target_health.push(100.0);
let mut ground = Ground::default();
let land = Land(|_, _| 64);
let mut out = Out::default();
for _ in 0..20 {
serve(&mut ground, &land, sim.tick);
sim.step(&mut ground, None, &mut out);
}
sim.order_raid(&order(), &[object], &mut out);
let s = sim.recon.sorties.first().expect("no recon sortie").clone();
let d = sim.drones.iter_mut().find(|d| d.id == s.drone).unwrap();
d.pos = s.zones[s.next].center + DVec3::Y * 40.0;
sim.tick += 1;
sim.step_recon(&mut out);
while sim.planning() {
serve(&mut ground, &land, sim.tick);
sim.tick += 1;
sim.plan_step(Some(&mut ground), &mut out);
}
let deadline = sim.refresh.as_ref().expect("the refresh was not armed").deadline;
let times: Vec<u64> = sim.queue.iter().map(|(t, _)| *t).collect();
// The report never arrives (the aircraft is lost); the deadline passes.
sim.drones.retain(|d| !recon::is_drone_id(d.id));
sim.tick = deadline + 1;
sim.step_refresh(&mut out);
assert!(sim.refresh.is_none(), "the refresh outlived its deadline");
assert_eq!(sim.refresh_applied, 0);
assert_eq!(sim.queue.iter().map(|(t, _)| *t).collect::<Vec<_>>(), times, "a missing report delayed a launch");
}
// #149: the bearing window forgets, and names why it explores. Few observations, a stale
// result and changed public conditions are distinct typed reasons; the legacy mode keeps its
// fixed share.
#[test]
fn the_bearing_window_forgets_and_names_its_reason() {
let mut sim = Sim::new(149);
sim.tick = 100;
for _ in 0..8 {
sim.learn(3, false);
}
sim.best_bearing();
let r = sim.bearing_report();
assert_eq!(r.reason, ew::BearingReason::Exploiting);
assert_eq!(r.observations, 8);
sim.tick = 100 + ew::OUTCOME_STALE + 1;
sim.best_bearing();
assert_eq!(sim.bearing_report().reason, ew::BearingReason::StaleResults);
sim.tick = 100 + ew::OUTCOME_WINDOW + 1;
sim.best_bearing();
let r = sim.bearing_report();
assert_eq!(r.reason, ew::BearingReason::FewObservations);
assert_eq!(r.observations, 0, "the window did not forget the old outcomes");
let mut sim = Sim::new(149);
sim.tick = 100;
for _ in 0..8 {
sim.learn(3, false);
}
let id = sim.id();
let radar = Sam::new(id, SamKind::Radar, DVec3::ZERO, 0.0);
sim.intel.observe(&radar, 100, ew::Seen::Emission);
sim.sams.push(radar);
sim.best_bearing();
assert_eq!(sim.bearing_report().reason, ew::BearingReason::ConditionsChanged);
sim.smart_legacy = true;
sim.best_bearing();
assert_eq!(sim.bearing_report().reason, ew::BearingReason::FixedShare);
}
// #149: the bearing window and a refresh intent are durable: a save writes them, a load reads
// them back, and an older save without the window loads with an empty one.
#[test]
fn the_bearing_window_and_a_refresh_intent_survive_a_save() {
let mut sim = Sim::new(149);
sim.tick = 500;
sim.learn(2, true);
sim.learn(5, false);
let mut d = sim.make_drone(DroneKind::Shahed, DVec3::new(-500.0, 120.0, 0.0), DVec3::X, DVec3::ZERO);
d.smart = true;
d.intent = ew::Intent::Refresh;
d.aim = ew::Aim::unit(recon::ID_BASE + 1, 500, Confidence::Confirmed);
sim.queue.push((600, d));
let text = sim.air_text().expect("the window and the queue are durable");
assert!(text.contains("airlearn"), "the bearing window was not written");
assert!(text.contains("refresh"), "the refresh intent was not written");
let mut back = Sim::new(1);
back.restore_air(Sim::parse_air(&text).expect("the save reads").expect("the air section is there"));
assert_eq!(back.intel.outcomes().len(), 2);
assert_eq!(back.queue[0].1.intent, ew::Intent::Refresh);
assert_eq!(back.queue[0].1.aim.unit, recon::ID_BASE + 1);
}
+39
View File
@@ -642,6 +642,45 @@ kills 59→58, 59→58, 56→63; hits 7→7, 7→9, 8→3; потери ЗРК 3
появляется). Adapter: `the_air_section_of_a_save_is_written_and_read_by_the_adapter` (запись/чтение
секции, замена не слияние, старый save без секции, сценарий без воздуха).
### #149: Smart v2 поверх #146 — единая разведкартина, цены отметок, ограниченный refresh, окно bearing
Продолжение #127/#135 **поверх уже интегрированного #146** (`KnowledgeSnapshot { tick, contacts, marks }`,
`knowledge_now()`, `Plan.knowledge`, `RouteJob.known`, версионные `price_grid_known`/restore). Инфраструктура
#146 не дублируется и не меняется: один снимок на приказ, цены по `known.tick`, версионный restore — как есть.
Новое наслоение:
- **Один публичный тип наблюдения** `sim::observe::Observation` (область/радиус, канал `recon::Source`,
возраст, уверенность, категория/роль/тип, качество, флаг `matched`). `observe::merge` сводит `Contact` и
`Mark` в один список **только по публичным признакам** (перекрытие области + точное совпадение категории);
coarse `Unknown` и противоречащая категория остаются отдельными подсказками, контакт не переписывает
тип/место, отметка добавляет лишь свежесть и refined-роль; `recon.truth` и реальные id не участвуют.
`KnowledgeSnapshot::observations()` (аддитивно) отдаёт этот список; одна шкала `Observation::rank`
заменила две разные в `radar_strikes`, `choose_target` и адаптивном выборе (сигнатуры kimi-work сохранены).
- **Цены отметок** в существующем `price_grid_known`: свежая (Probable/Confirmed) отметка launcher/gun/jammer
ценит клетки по published-огибающей категории (`observe::category_envelope`), взвешенной уверенностью
(Confirmed ×1, Probable ×0.5); radar-отметка кормит сетевую веру ПУ рядом (`observe::radar_envelope`);
совпавшая с контактом ценится один раз через контакт; doubtful не ценится.
- **Ограниченный refresh не выпущенной части**: пока разведчики в воздухе, при завершении плана взводится
`ew::Refresh { deadline, reports }` с абсолютным дедлайном `REFRESH_WINDOW=600`. `step_refresh` один раз,
при приходе донесения, перенацеливает queued-дроны с intent Plan/Sead на свежий снимок (typed
`Intent::Refresh`, приоритет SEAD) в пределах `SWITCH_CAP` и бюджетов. Нет донесения — пуски не задерживаются.
- **Окно bearing**: `Intel.outcomes` — bounded `VecDeque<Learned>` (48 записей, окно 12000 тиков);
`best_bearing` кандидата скорит окно и адаптирует долю исследования по typed `BearingReason`
(few/stale/conditions-changed/exploiting); «условия» — fingerprint публичной картины, не скрытое состояние.
Legacy сохраняет пожизненные kills/hits и фиксированные 0.3 (`FixedShare`). Диагностика —
`Sim::bearing_report()`, поля `bearing/refresh_waiting/refresh_applied/observations` в `EnemyPictureReport`.
- **Сравнительный runner** `cargo run --release --example smart_bench`: simple / current (legacy) / candidate
на seed 1/7/42, сценарии open/hills/config-change/recon-lost; JSON и строки (полезные решения, разнообразие,
jitter ≥2 переключений, reasons/intents, bearing reason, refresh, CPU p95/max, worst jobs).
`Sim::smart_legacy` воспроизводит текущий Smart kimi-work (включая #146) для честного сравнения;
`harness::run_with_hook` меняет оборону между волнами и сбивает разведчика до донесения. Лёгкий режим и
bounded jobs не тронуты; policy не читает здоровье/заряды/скрытые переключатели/позиции мира.
- **Тесты** `sim::smart_tests` + `sim::observe::tests`: метаморфный hidden-layout до/после наблюдения, дедуп
по публичным признакам, отметки в ценах, одна версия на приказ (обе моды чтят #146), bounded refresh
(срабатывает один раз / не паузит), окно bearing и причины, durable окна (`airlearn`) и `Intent::Refresh`.
Регрессия relief-версий сохранена; стена в её фикстуре расширена по z, чтобы пересекать любой восток-запад
маршрут после смены порядка назначений кандидатом.
## Что следующему агенту проверить в первую очередь
1. На Windows: обновление сабмодуля через `all`, сохранение/перезаход, рабочий цикл игры.