Add passive optical observation post (#136)

- new Optical unit kind with its own catalog row and deploy item
- bounded one-contact line-of-sight checks against land and blocks
- day/night reach and hold timing; obstacle and unknown geometry block sight
- independent class observation with source, time and uncertainty, never DroneKind
- map/monitor/panel statuses and a line to the selected contact
- tests: day/night, wall/unknown, ageing, no kind leak, bounded work, passivity

Cherry-picked from 3ae21123964a9d3234bb2b3efc9ff926d64fc77d onto the
#132/#133/#134 base: the cue test's track literal now carries the shared
class/source/product/quality contract instead of a DroneKind.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
2026-11-20 22:26:16 +03:00
parent 53fbeced22
commit e5ee15a2ca
23 changed files with 1139 additions and 27 deletions
@@ -0,0 +1,6 @@
{
"model": {
"type": "minecraft:model",
"model": "airdef:item/deploy_optical"
}
}
+1
View File
@@ -123,6 +123,7 @@
"item.airdef.deploy_tzm": "Развернуть ТЗМ",
"item.airdef.deploy_ew": "Развернуть станцию РЭБ",
"item.airdef.deploy_light": "Развернуть прожектор",
"item.airdef.deploy_optical": "Развернуть оптический пост",
"item.airdef.mover": "Пульт перемещения",
"item.airdef.flare_gun": "Осветительная ракета",
"item.airdef.remover": "Свернуть ПВО",
+1
View File
@@ -123,6 +123,7 @@
"item.airdef.deploy_tzm": "Развернуть ТЗМ",
"item.airdef.deploy_ew": "Развернуть станцию РЭБ",
"item.airdef.deploy_light": "Развернуть прожектор",
"item.airdef.deploy_optical": "Развернуть оптический пост",
"item.airdef.mover": "Пульт перемещения",
"item.airdef.flare_gun": "Осветительная ракета",
"item.airdef.remover": "Свернуть ПВО",
@@ -0,0 +1,6 @@
{
"parent": "minecraft:item/generated",
"textures": {
"layer0": "airdef:item/deploy_radar"
}
}
@@ -0,0 +1,4 @@
{
"template": "minecraft:stick",
"max_stack_size": 1
}
+13
View File
@@ -72,6 +72,16 @@ pub fn sam_status(sam: &Sam) -> String {
return format!("{text} «{}»: {}; целей {}{broken}, {channels}", profile.name, profile.products_text(), sam.own.len());
}
SamKind::Light => return format!("{text}{}", if sam.target.is_some() { ": в луче цель" } else { "" }),
SamKind::Optical => {
let mut t = format!("{text}: {}", sam.optical.status_text());
if sam.health < 1.0 {
t += &format!(" ({:.0}%)", sam.health * 100.0);
}
if !sam.comps.whole() {
t += &format!(" [{}]", crate::why_view::worst(&sam.comps, sam.kind));
}
return t;
}
_ => {}
}
if let Some(cell) = sam.preparing_cell() {
@@ -158,6 +168,9 @@ mod tests {
let mut light = Sam::new(8, SamKind::Light, DVec3::ZERO, 0.0);
light.target = Some(1);
assert_eq!(sam_status(&light), "Прожектор: в луче цель");
let optical = Sam::new(9, SamKind::Optical, DVec3::ZERO, 0.0);
assert_eq!(sam_status(&optical), "Оптический пост: ищет");
}
#[test]
+7
View File
@@ -244,6 +244,13 @@ mod tests {
SamKind::Patriot.key()
}
#[test]
fn an_optical_post_loads_by_its_catalog_key() {
let l = Layout::parse("sam optical 10 70 20 0.5\n").unwrap();
assert_eq!(l.sams[0].kind, SamKind::Optical);
assert_eq!(l.sams[0].mode, sim::battery::SamMode::Integrated);
}
// #86: the issue's file, and the other ways a saved state can be wrong: refused whole, with the line
#[test]
fn a_damaged_state_is_refused_as_a_whole_with_its_line_and_field() {
+6 -2
View File
@@ -1505,7 +1505,7 @@ impl AirDef {
.sams
.iter()
.enumerate()
.filter(|(_, s)| s.kind.armed() || s.kind == SamKind::Radar)
.filter(|(_, s)| s.kind.armed() || s.kind == SamKind::Radar || s.kind == SamKind::Optical)
.map(|(i, s)| {
let busy = if self.sim.showing_kill(s) { 98.0 } else { match s.state {
sim::SamState::Launch | sim::SamState::Fire => 100.0,
@@ -1519,7 +1519,11 @@ impl AirDef {
sim::SamState::Waiting => 35.0,
sim::SamState::Packing | sim::SamState::Moving | sim::SamState::Deploying => 40.0,
} };
let near = self.sim.watched(s).map_or(0.0, |d| 15.0 * (1.0 - (d.pos.distance(s.pos) / s.kind.range()).min(1.0)));
let near = if s.kind == SamKind::Optical {
0.0
} else {
self.sim.watched(s).map_or(0.0, |d| 15.0 * (1.0 - (d.pos.distance(s.pos) / s.kind.range()).min(1.0)))
};
let hurt = if s.alive() && s.health < 0.7 { 15.0 } else { 0.0 };
let keep = if shown.contains(&s.id) { 12.0 } else { 0.0 };
let pinned = if self.monitor == Some(i) { 1000.0 } else { 0.0 };
+63 -1
View File
@@ -465,7 +465,7 @@ impl MapUi {
fn sys_class(k: SamKind) -> usize {
if k.armed() {
if k == SamKind::Gepard { 1 } else { 0 }
} else if k.spec().sensor > 0.0 {
} else if k == SamKind::Optical || k.spec().sensor > 0.0 {
2
} else {
3
@@ -480,6 +480,7 @@ fn short_name(k: SamKind) -> &'static str {
SamKind::Tzm => "ТЗМ",
SamKind::Ew => "РЭБ",
SamKind::Light => "Прож.",
SamKind::Optical => "Опт.",
SamKind::Pantsir => "Панцирь",
SamKind::IrisT => "IRIS-T",
SamKind::S400 => "С-400",
@@ -1778,6 +1779,10 @@ impl AirDef {
if ui.filters[F_TRACKS] || ui.filters[F_TRAILS] {
self.map_tracks(ui, &mut s, &mut labs, &mut taken);
}
// The optical posts and the contacts they watch (#136): a line to a contact last seen in clear sight.
if ui.filters[F_SAMS] || ui.filters[F_TRACKS] {
self.map_optical(ui, &mut s, &mut labs);
}
// The truth, when the sandbox shows it, marked as such: the real drones, their routes and aims.
if self.sim.truth {
map_truth(&self.sim, ui, hover, &mut s, &mut labs, &mut taken);
@@ -1902,6 +1907,51 @@ impl AirDef {
}
}
/// The optical posts (#136): a short status by each, and a line to the contact it has in clear
/// sight (or last saw), never to a radar's measurement. At most a screenful, so a crowd stays cheap.
fn map_optical(&self, ui: &mut MapUi, s: &mut Vec<Shape>, labs: &mut Vec<Lab>) {
let now = self.sim.tick;
let picture = self.sim.picture();
let mut drawn = 0usize;
for (i, sam) in self.sim.sams.iter().enumerate().filter(|(_, sam)| sam.kind == SamKind::Optical && sam.alive()) {
if drawn >= 16 {
break;
}
let c = ui.to_screen(sam.pos.x, sam.pos.z);
if !ui.on_screen(c, 30.0) {
continue;
}
drawn += 1;
let Some(report) = self.sim.optical_report(sam.id) else { continue };
let chosen = ui.sel == Some(Sel::Sam(sam.id));
let color = match report.state {
sim::OpticalState::Observing => GREEN,
sim::OpticalState::Holding => CYAN,
sim::OpticalState::NoSight => ORANGE,
sim::OpticalState::Searching => GREY,
};
add_lab(ui, labs, format!("Опт. №{}: {}", i + 1, report.status()), c, 7.0, alpha(color, 0.95), chosen);
if chosen {
s.extend(frame(c.0 - 8.0, c.1 - 8.0, 16.0, 16.0, 1.0, GREEN));
}
// The contact it watches: its own last clear sighting, else the network cue's forecast.
let own = report.seen.is_some();
let point = report
.seen
.or_else(|| report.target.and_then(|id| picture.get(&id).map(|t| t.est(now))));
if let Some(p) = point {
let pc = ui.to_screen(p.x, p.z);
s.push(line(c, pc, 1.0, alpha(color, if chosen { 0.9 } else if own { 0.55 } else { 0.3 })));
let label = match (own, report.observation) {
(true, Some(o)) => format!("вероятно {} · {:.0}%", o.class.name(), (1.0 - o.uncertainty) * 100.0),
(true, None) => "контакт в поле зрения".into(),
(false, _) => "цель по подсказке".into(),
};
add_lab(ui, labs, label, pc, 5.0, alpha(color, 0.95), chosen);
}
}
}
/// The radars' coverage edges. A radar's edge is where the land first hides a low flyer along each ray round it;
/// each is worked out from the sim's own horizon (`low_rim`), a few a redraw, and kept a while. The selected
/// one shows its dead zones filled.
@@ -2663,6 +2713,18 @@ impl AirDef {
btns.push((if sam.radar_on { "Выключить РЛС" } else { "Включить РЛС" }.into(), Act::RadarEmission, sam.radar_on));
}
lines.push((crate::battery_view::sam_status(sam), WHITE));
if k == SamKind::Optical {
if let Some(r) = self.sim.optical_report(sam.id) {
lines.push((r.line(), WHITE));
if let Some(o) = r.observation {
lines.push((format!("Последнее наблюдение: {} · {} с назад", o.class.name(), o.age(now) / 20), WHITE));
}
lines.push(("Пассивный пост: не излучает и не ведёт огневой трек".into(), GREY));
if r.target.is_some() {
lines.push(("Выбранный контакт показан линией".into(), GREY));
}
}
}
lines.push((format!("Исправен {:.0}% · {:.0} {:.0}", sam.health * 100.0, sam.pos.x, sam.pos.z), GREY));
if k == SamKind::Depot {
lines.push((format!("Ударные RM48U: {} · снятые 48Н6: {}", sam.ground_stock, sam.air_48n6_stock), WHITE));
+64 -15
View File
@@ -3,7 +3,7 @@
//! renders it) locked on its target. K shows one system at a time, J all of
//! them in a grid.
use crate::panel::distance;
use crate::sim::{ClassEst, Sam, SamState, Sim, heading_of, roles_text};
use crate::sim::{ClassEst, OpticalState, Sam, SamKind, SamState, Sim, heading_of, roles_text};
use glam::DVec3;
use horizon_mod_sdk::render::{self, CameraView, FillShape, Point, QuadShape, Rect, Shape, TextShape, ViewShape};
@@ -91,12 +91,23 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
s.push(fill(x, y, w, h, 0xC0080C0A));
s.push(fill(x, y, w, 12.0, 0xE0142018));
let state = sam.state;
let optical = sam.kind == SamKind::Optical;
let lock = matches!(state, SamState::Lock | SamState::Launch | SamState::Fire);
let blink = lock && (tick / 4) % 2 == 0;
let label = state.name();
let label = if optical { sam.optical.state().name() } else { state.name() };
let color = if optical {
match sam.optical.state() {
OpticalState::Observing => 0xFF60FF80,
OpticalState::Holding => 0xFF9FE0FF,
OpticalState::NoSight => 0xFFFFA040,
OpticalState::Searching => 0xFFE0E0E0,
}
} else {
state.color()
};
let lw = render::text_width(label);
s.push(text(fit(format!("№{} {}", index + 1, spec.name), w - lw - 12.0), x + 3.0, y + 2.0, 0xFF9FE0FF));
s.push(text(label, x + w - 3.0 - lw, y + 2.0, argb(state.color(), if blink { 0x80 } else { 0xFF })));
s.push(text(label, x + w - 3.0 - lw, y + 2.0, argb(color, if blink { 0x80 } else { 0xFF })));
// The radar, at the left: round the system, north up.
let rr = ((h - 28.0) / 2.0).min(w * 0.2).max(10.0);
@@ -114,9 +125,13 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
}
// A system that only fires (no radar) has no reach: a radar's sensor
// range stands in, and nothing is divided by zero.
let reach = match sam.kind.range() {
r if r > 0.0 => r,
_ => spec.sensor,
let reach = if optical {
crate::sim::OPTICAL_RANGE
} else {
match sam.kind.range() {
r if r > 0.0 => r,
_ => spec.sensor,
}
};
let scale = if reach > 0.0 { rr as f64 / (reach * 1.25) } else { 0.0 };
// The beam is the radar's real one: targets are measured as it passes them.
@@ -168,7 +183,9 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
}
}
s.push(fill(rx - 1.5, ry - 1.5, 3.0, 3.0, 0xFF40A0FF));
let radar_text = if spec.sensor <= 0.0 {
let radar_text = if optical {
format!("ОПТИКА · {}", sam.optical.state().name())
} else if spec.sensor <= 0.0 {
format!("сеть · {seen}")
} else if radar_up {
let profile = sam.radar_profile();
@@ -177,7 +194,19 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
} else {
"РЛС ОТКАЗ".to_string()
};
s.push(text(fit(radar_text, rr * 2.0 + 4.0), x + 4.0, y + h - 10.0, if spec.sensor > 0.0 && !radar_up { 0xFFFF5040 } else { 0xFF80FF90 }));
let radar_color = if optical {
match sam.optical.state() {
OpticalState::Observing => 0xFF60FF80,
OpticalState::Holding => 0xFF9FE0FF,
OpticalState::NoSight => 0xFFFFA040,
OpticalState::Searching => 0xFFB0B0B0,
}
} else if spec.sensor > 0.0 && !radar_up {
0xFFFF5040
} else {
0xFF80FF90
};
s.push(text(fit(radar_text, rr * 2.0 + 4.0), x + 4.0, y + h - 10.0, radar_color));
// Its health under the radar: a bar, red when it is low.
if sam.alive() && sam.health < 1.0 {
@@ -223,6 +252,21 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
s.push(fill(cx + 3.0, cy + ch / 2.0 - 0.5, cw * 0.18, 1.0, 0x90FFFFFF));
s.push(fill(cx + cw * 0.82 - 3.0, cy + ch / 2.0 - 0.5, cw * 0.18, 1.0, 0x90FFFFFF));
match target {
Some(_) if optical => {
// The optical post's picture: its own class observation, never the true model name.
let (color, info) = match sam.optical.state() {
OpticalState::Observing => (0xFF60FF80, sam.optical.status_text()),
OpticalState::Holding => (0xFF9FE0FF, sam.optical.status_text()),
OpticalState::NoSight => (0xFFFFA040, sam.optical.status_text()),
OpticalState::Searching => (0xFFB0B0B0, sam.optical.status_text()),
};
let (bw, bh) = (cw * 0.3, ch * 0.34);
brackets(s, cx + cw / 2.0 - bw / 2.0, cy + ch / 2.0 - bh / 2.0, bw, bh, 6.0, color);
if ch > 50.0 {
s.push(text(fit(info.clone(), cw - 6.0), cx + 3.0, cy + ch - 20.0, color));
}
s.push(text(fit(info, cw - 6.0), cx + 3.0, cy + ch - 10.0, 0xFFC0FFC0));
}
Some(t) => {
let color = if lock { if blink { 0xFFFF3030 } else { 0xFFFF8080 } } else { 0xFFFFE060 };
let (bw, bh) = (cw * 0.3, ch * 0.34);
@@ -257,19 +301,24 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
}
s.push(text(fit(info, cw - 6.0), cx + 3.0, cy + ch - 10.0, 0xFFC0FFC0));
}
None if optical => s.push(text(fit(sam.optical.status_text(), cw - 6.0), cx + 3.0, cy + ch - 10.0, 0xFFB0B0B0)),
None => s.push(text("ПОИСК", cx + 3.0, cy + ch - 10.0, 0xFF80FF90)),
}
// What it carries and does.
let mut line = String::new();
if !matches!(sam.kind, crate::sim::SamKind::Gepard) {
line += &format!("Р{} ", sam.missiles);
if sam.kind == crate::sim::SamKind::S400 { line += &format!("У{} ", sam.ground_rounds); }
if optical {
line = sam.optical.status_text();
} else {
if !matches!(sam.kind, SamKind::Gepard) {
line += &format!("Р{} ", sam.missiles);
if sam.kind == SamKind::S400 { line += &format!("У{} ", sam.ground_rounds); }
}
if crate::sim::catalog::unit(sam.kind).has_gun() {
line += &format!("Оч{} ", sam.bursts);
}
line += &format!("сб.{} [{}]", sam.kills, roles_text(sam.roles));
}
if crate::sim::catalog::unit(sam.kind).has_gun() {
line += &format!("Оч{} ", sam.bursts);
}
line += &format!("сб.{} [{}]", sam.kills, roles_text(sam.roles));
s.push(text(fit(line, cw), cx, y + h - 10.0, 0xFF9FE0FF));
}
+5
View File
@@ -88,6 +88,11 @@ pub fn summary(sim: &Sim, pic: &AirPicture, player: DVec3) -> Vec<Line> {
let worst = sim.target_health.iter().copied().fold(100.0, f64::min);
lines.push(line(format!("Объекты: {}", list.join(" ")), if worst < 50.0 { RED } else { GREEN }));
}
// The passive optical posts (#136): their own status and source, never a radar's emission.
let optics = sim.optical_reports();
if let Some(r) = optics.iter().find(|r| r.state == crate::sim::OpticalState::Observing).or_else(|| optics.first()) {
lines.push(line(format!("Опт. №{}: {}", r.index, r.line()), CYAN));
}
let lost = sim.sams.iter().filter(|s| !s.alive()).count();
if lost > 0 {
lines.push(line(format!("Потеряно комплексов: {lost}"), RED));
+1
View File
@@ -31,4 +31,5 @@ pub const UNITS: &[Unit] = &[
Unit { kind: SamKind::Tzm, deploy_item: "airdef:deploy_tzm" },
Unit { kind: SamKind::Ew, deploy_item: "airdef:deploy_ew" },
Unit { kind: SamKind::Light, deploy_item: "airdef:deploy_light" },
Unit { kind: SamKind::Optical, deploy_item: "airdef:deploy_optical" },
];
+2 -1
View File
@@ -61,7 +61,8 @@ impl Part {
pub fn on(self, kind: SamKind) -> bool {
let spec = kind.spec();
match self {
Part::Sensor => spec.sensor > 0.0,
// A passive optical post has a sensor without radar reach: it can be damaged and blinded too.
Part::Sensor => spec.sensor > 0.0 || kind == SamKind::Optical,
Part::Mount => kind.armed() && kind != SamKind::Light && (spec.missile.is_some() || spec.gun.is_some()),
Part::Launcher => spec.missile.is_some(),
Part::Gun => spec.gun.is_some(),
+21 -2
View File
@@ -25,6 +25,7 @@ pub mod record;
mod sight;
mod terrain;
mod ew;
mod optical;
mod durable;
pub use ew::{AimReport, Confidence, ContactReport, EnemyPictureReport, Intent, PendingReport};
pub mod lights;
@@ -45,6 +46,9 @@ mod sensor_tests;
pub use ew::EW_RADIUS;
pub use damage::{Comps, Part, PartState};
pub use sight::{AirPicture, Ident, LowSensor, Track, RIM_RAYS};
pub use optical::{Optical, OpticalClassEstimate, OpticalObservation, OpticalObservable, OpticalReport, OpticalState, SightBlock};
/// The passive optical post's clear-day reach (the monitor's scale reads it).
pub const OPTICAL_RANGE: f64 = optical::RANGE;
use damage::dice;
use outcome::{Impact, Outcome};
pub use units::{Family, SamKind};
@@ -1240,6 +1244,8 @@ pub struct Sam {
pub(super) terrain: HashMap<u32, (u64, u8)>,
/// Targets whose land hasn't been answered yet, and since when it has been waited for.
waits: HashMap<u32, u64>,
/// A passive optical post's own state (#136): no radar, no track, one class observation at a time.
pub optical: Optical,
}
impl Sam {
@@ -1313,6 +1319,7 @@ impl Sam {
beam_cast: 0,
terrain: HashMap::new(),
waits: HashMap::new(),
optical: Optical::default(),
}
}
pub fn alive(&self) -> bool {
@@ -1552,6 +1559,12 @@ impl Sim {
{
return self.drones.iter().find(|d| d.id == id);
}
// An optical post has no track: its camera looks where it last saw the contact in clear
// sight, and nowhere at all while it has not seen it (#136).
if sam.kind == SamKind::Optical {
let (id, _) = sam.optical.seen(self.tick)?;
return self.drones.iter().find(|d| d.id == id);
}
let id = sam
.gun_target
.or(sam.target)
@@ -1567,6 +1580,9 @@ impl Sim {
{
return Some(self.watched(sam).map_or(at, |d| d.pos));
}
if sam.kind == SamKind::Optical {
return sam.optical.seen(self.tick).map(|(_, p)| p);
}
self.watched(sam).map(|d| d.pos)
}
@@ -2306,7 +2322,7 @@ impl Sim {
if self.hold {
for i in 0..self.sams.len() {
if self.sams[i].alive() && !self.sams[i].moving() {
if self.sams[i].alive() && !self.sams[i].moving() && self.sams[i].kind != SamKind::Optical {
self.sams[i].state = SamState::Hold;
}
self.draw_sam(i, out);
@@ -2362,7 +2378,10 @@ impl Sim {
}
if !self.sams[i].kind.armed() {
let sam = &mut self.sams[i];
sam.state = SamState::Search;
// An optical post's state is its optics' (#136), not the armed systems' search line.
if sam.kind != SamKind::Optical {
sam.state = SamState::Search;
}
// A searchlight's target is its beam's (step_lights): kept for its spot of light.
if sam.kind != SamKind::Light {
retarget(&mut missile_on, sam.target.take(), None);
+854
View File
@@ -0,0 +1,854 @@
//! A passive optical observation post (#136): a separate, stationary sensor that watches one
//! already-known contact at a time and says what *class* of thing it is, without naming the model.
//!
//! It is deliberately not a radar and not a [`RadarRole`](battery::RadarRole): its spec has no
//! radar reach (`sensor = 0`), so it never appears in the radar picture, never emits, and never feeds
//! a fire-control track. It gets its contact either from the network's tracks (a cue) or by looking
//! in its own narrow near sector; then it must hold that one contact in clear line of sight for a
//! while. The result is an independent [`OpticalObservation`] with source, time, a wide [`Class`]
//! and an uncertainty — not a fresh [`Track`], not a measurement added to a radar's, and not a new
//! network emission.
//!
//! Line of sight is bounded work: one contact per post, one probe every few ticks, at most
//! [`CHECKS_PER_TICK`] optical probes a tick in the whole simulation. An unknown block section or an
//! unknown land column is *not* a clear line: the post keeps the old observation (which ages) and
//! waits for the game to answer. Night shortens the reach and doubles the hold; there is no thermal
//! mode in this first version. Weather/fog is not in the simulation API yet, so only the game's own
//! day/night state and the world geometry are used here.
//!
//! #133 owns the shared class-estimate contract. This module keeps its own small
//! [`OpticalObservation`]/[`OpticalClassEstimate`] types rather than inventing that contract silently: a
//! future classifier can consume [`Sim::optical_reports`] or the observation's [`OpticalClassEstimate`]
//! without this post pretending to be a [`Track`]. Nothing here reads [`DroneKind`] to classify.
//!
//! The catalog row currently reuses the existing `airdef:radar_truck` and `airdef:radar_panel`
//! models, and the deploy item aliases the radar icon, until the optical post's own assets land.
use super::*;
use super::world::Sweep;
/// How far the post's optics resolve a contact in clear daytime air, blocks.
pub const RANGE: f64 = 300.0;
/// How far a network cue may point the head; beyond `RANGE` it is only a direction to look.
pub const CUE_RANGE: f64 = 800.0;
/// Half-width of the local search sector, radians.
const SECTOR_HALF: f64 = 70.0_f64.to_radians();
/// Ticks a contact must stay in clear sight: day, and night.
const HOLD_DAY: u32 = 25;
const HOLD_NIGHT: u32 = 60;
/// Beyond this at night the optics resolve nothing.
const NIGHT_RANGE: f64 = 150.0;
/// A post probes its contact this often; the phase spreads posts over the period.
const PERIOD: u64 = 5;
/// Optical line-of-sight probes a tick, for the whole simulation.
pub const CHECKS_PER_TICK: usize = 4;
/// Nearest local candidates compared per look (one is selected).
const LOCAL_CANDIDATES: usize = 8;
/// Land samples a line is checked against (each may ask the game for its column).
const TERRAIN_SAMPLES: usize = 6;
/// A relayed track older than this is not worth turning the head for.
const CUE_MAX_AGE: u64 = 120;
/// Where the antenna sits over the post's base, blocks.
const MAST: f64 = 2.5;
/// What the post is doing, in the words the map and monitor use.
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub enum OpticalState {
/// No contact selected.
#[default]
Searching,
/// One contact selected, not yet held long enough (the post is "busy" with it).
Holding,
/// It has produced an observation and still watches the same contact.
Observing,
/// A contact is selected but the line is blocked or unresolved.
NoSight,
}
impl OpticalState {
pub fn name(self) -> &'static str {
match self {
Self::Searching => "ищет",
Self::Holding => "занят",
Self::Observing => "наблюдает",
Self::NoSight => "нет видимости",
}
}
}
/// Why the selected contact cannot be confirmed now.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum SightBlock {
/// Beyond the optics' reach (a cue may point farther than they resolve).
OutOfRange,
/// Too far for the reduced night reach.
Night,
/// The land itself rises into the line.
Terrain,
/// A known block stops the line (a wall, a building).
Obstacle,
/// Geometry along the line is not known: not a clean line of sight.
UnknownGeometry,
/// The sensor part has failed.
Sensor,
}
impl SightBlock {
pub fn name(self) -> &'static str {
match self {
Self::OutOfRange => "вне дальности",
Self::Night => "ночь",
Self::Terrain => "рельеф",
Self::Obstacle => "препятствие",
Self::UnknownGeometry => "геометрия неизвестна",
Self::Sensor => "оптика отказала",
}
}
}
/// What can be observed of a contact's motion, without its true model or kind.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OpticalObservable {
/// Speed, blocks a tick.
pub speed: f64,
/// Vertical speed, blocks a tick (negative: descending).
pub climb: f64,
/// Distance from the post, blocks.
pub range: f64,
}
/// A provisional wide class from observable motion alone. #133 will own the shared classifier;
/// this function is the one place that provisional rule lives, and it never looks at `DroneKind`.
/// Equal observable data therefore gives an equal answer for different true models.
pub fn classify_optical(observable: OpticalObservable) -> Class {
let speed = observable.speed;
if speed >= 6.5 || (speed >= 3.0 && observable.climb <= -0.35) {
Class::Ballistic
} else if speed >= 3.0 {
Class::Supersonic
} else if speed >= 1.8 {
Class::Cruise
} else if speed >= 0.8 {
Class::Jet
} else {
Class::Drone
}
}
/// The minimum a future class-estimate consumer (#133) needs from one optical observation.
/// Deliberately local: the shared contract is not invented here.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OpticalClassEstimate {
pub class: Class,
/// 0 best, 1 worst.
pub uncertainty: f64,
}
/// One independent optical observation: who saw it, when, what wide class, and how unsure.
/// It contains no [`DroneKind`], no track hits and no fire-control state.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OpticalObservation {
/// The contact's track id (opaque to the player's data).
pub target: u32,
/// The post's unit id: the observation's source.
pub source: u32,
pub tick: u64,
pub class: Class,
/// 0 best, 1 worst.
pub uncertainty: f64,
pub range: f64,
/// Bearing from the post, radians (as `heading_of`).
pub bearing: f64,
/// Ticks the contact was held before this observation.
pub hold: u32,
/// The observation was made at night.
pub night: bool,
}
impl OpticalObservation {
pub fn age(&self, now: u64) -> u64 {
now.saturating_sub(self.tick)
}
/// The adapter to the future #133 contract.
pub fn estimate(&self) -> OpticalClassEstimate {
OpticalClassEstimate { class: self.class, uncertainty: self.uncertainty }
}
}
/// One post's passive optics: the contact it is on, its line-of-sight state and its last observation.
#[derive(Clone, Debug, Default)]
pub struct Optical {
target: Option<u32>,
/// A player/network priority for a contact, when one is given.
commanded: Option<u32>,
state: OpticalState,
block: Option<SightBlock>,
held: u32,
observations: u32,
observation: Option<OpticalObservation>,
/// The last clear sighting of the current contact: target, where it was, its velocity then, when.
/// Only a clear line writes it; a blocked line leaves the old one to be forecast, never refreshed.
seen: Option<(u32, DVec3, DVec3, u64)>,
checks: u64,
}
impl Optical {
pub fn state(&self) -> OpticalState {
self.state
}
pub fn block(&self) -> Option<SightBlock> {
self.block
}
pub fn target(&self) -> Option<u32> {
self.target
}
pub fn observation(&self) -> Option<OpticalObservation> {
self.observation
}
/// Where the current contact was last seen in clear sight, carried on by its velocity then.
/// None when the post has not seen it, or its old sighting belongs to another contact.
pub fn seen(&self, now: u64) -> Option<(u32, DVec3)> {
let (id, pos, vel, tick) = self.seen?;
(self.target == Some(id)).then(|| (id, pos + vel * now.saturating_sub(tick) as f64))
}
pub fn observations(&self) -> u32 {
self.observations
}
pub fn checks(&self) -> u64 {
self.checks
}
fn commanded(&self) -> Option<u32> {
self.commanded
}
fn required(&self, night: bool) -> u32 {
if night { HOLD_NIGHT } else { HOLD_DAY }
}
fn clear_activity(&mut self) {
self.target = None;
self.held = 0;
self.state = OpticalState::Searching;
self.block = None;
}
fn drop_target(&mut self) {
self.target = None;
self.commanded = None;
self.held = 0;
self.observations = 0;
self.seen = None;
self.state = OpticalState::Searching;
self.block = None;
}
fn select(&mut self, id: Option<u32>) {
if self.target != id {
self.held = 0;
self.observations = 0;
self.seen = None;
}
self.target = id;
self.block = None;
self.state = if id.is_some() { OpticalState::Holding } else { OpticalState::Searching };
}
/// A short line for the panel and the monitor: status, class and uncertainty, never a model name.
pub fn status_text(&self) -> String {
match self.state {
OpticalState::Searching => "ищет".into(),
OpticalState::Holding => "занят: удерживает контакт".into(),
OpticalState::Observing => match self.observation {
Some(o) => format!("наблюдает: вероятно {} ({:.0}%)", o.class.name(), (1.0 - o.uncertainty) * 100.0),
None => "наблюдает".into(),
},
OpticalState::NoSight => match self.block {
Some(b) => format!("нет видимости: {}", b.name()),
None => "нет видимости".into(),
},
}
}
fn report(&self, post: u32, index: usize, now: u64, night: bool) -> OpticalReport {
OpticalReport {
post,
index,
state: self.state,
block: self.block,
target: self.target,
observation: self.observation,
observations: self.observations,
held: self.held,
required: self.required(night),
seen: self.seen(now).map(|(_, p)| p),
checks: self.checks,
night,
}
}
}
/// A post's state as the map, monitor and panel read it.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OpticalReport {
/// The unit id of the post (the source of its observations).
pub post: u32,
/// Its 1-based place among the systems, for the interface.
pub index: usize,
pub state: OpticalState,
pub block: Option<SightBlock>,
pub target: Option<u32>,
pub observation: Option<OpticalObservation>,
pub observations: u32,
pub held: u32,
pub required: u32,
/// Where the current contact was last seen, forecast; None before the first clear sighting.
pub seen: Option<DVec3>,
pub checks: u64,
pub night: bool,
}
impl OpticalReport {
pub fn status(&self) -> &'static str {
self.state.name()
}
/// "источник — оптический пост №N": the post itself, never a radar that cued it.
pub fn source_text(&self) -> String {
format!("оптический пост №{}", self.index)
}
pub fn line(&self) -> String {
match self.state {
OpticalState::Searching => "ищет".into(),
OpticalState::Holding => format!("занят: удерживает контакт {}/{}", self.held, self.required),
OpticalState::Observing => match self.observation {
Some(o) => format!(
"наблюдает: вероятно {} · {:.0}% · источник — {}",
o.class.name(),
(1.0 - o.uncertainty) * 100.0,
self.source_text()
),
None => "наблюдает".into(),
},
OpticalState::NoSight => match self.block {
Some(b) => format!("нет видимости: {}", b.name()),
None => "нет видимости".into(),
},
}
}
/// The observation's age, if it has one; an old observation only ages.
pub fn age(&self, now: u64) -> Option<u64> {
self.observation.map(|o| o.age(now))
}
}
impl Sim {
/// Every live optical post's state, in deployment order (map/panel/monitor).
pub fn optical_reports(&self) -> Vec<OpticalReport> {
self.sams
.iter()
.enumerate()
.filter(|(_, s)| s.kind == SamKind::Optical && s.alive())
.map(|(i, s)| s.optical.report(s.id, i + 1, self.tick, self.night))
.collect()
}
pub fn optical_report(&self, id: u32) -> Option<OpticalReport> {
let (i, s) = self.sams.iter().enumerate().find(|(_, s)| s.id == id && s.kind == SamKind::Optical)?;
Some(s.optical.report(s.id, i + 1, self.tick, self.night))
}
/// A manual priority for the post: watch this contact, or (None) go back to cues and the local sector.
/// False for a post that is not an optical post or a contact that is not in the air.
pub fn assign_optical(&mut self, post: u32, target: Option<u32>) -> bool {
if target.is_some_and(|id| !self.drones.iter().any(|d| d.id == id && d.alive())) {
return false;
}
let Some(sam) = self.sams.iter_mut().find(|s| s.id == post && s.kind == SamKind::Optical && s.alive()) else {
return false;
};
sam.optical.commanded = target;
if sam.optical.target != target {
sam.optical.target = None;
sam.optical.held = 0;
sam.optical.observations = 0;
sam.optical.state = OpticalState::Searching;
sam.optical.block = None;
}
true
}
/// The post's own pick: a manual/network cue first, then its narrow near sector. At most one contact.
fn optical_target(&self, i: usize, now: u64, alive: &std::collections::HashSet<u32>) -> Option<u32> {
let sam = &self.sams[i];
let optical = &sam.optical;
let alive = |id: u32| alive.contains(&id);
if let Some(id) = optical.commanded() {
if alive(id) {
return Some(id);
}
}
if let Some(id) = optical.target() {
if let Some(d) = self.drones.iter().find(|d| d.id == id && d.alive()) {
if d.pos.distance(sam.pos) <= CUE_RANGE {
return Some(id);
}
}
}
// The network's freshest cue: the post measures it itself, the relay only points the head.
let mut cue: Option<(u64, f64, u32)> = None;
for t in &sam.tracks {
if t.own_tick != 0 || t.age(now) > CUE_MAX_AGE || !alive(t.id) {
continue;
}
let dist = t.est(now).distance(sam.pos);
if dist > CUE_RANGE {
continue;
}
if cue.is_none_or(|(fresh, near, _)| t.tick > fresh || (t.tick == fresh && dist < near)) {
cue = Some((t.tick, dist, t.id));
}
}
if let Some((_, _, id)) = cue {
return Some(id);
}
// Nothing cued: search a narrow near sector, nearest first, comparing no more than a few.
let mut local: Vec<(f64, u32)> = self
.drones
.iter()
.filter(|d| d.alive())
.filter_map(|d| {
let rel = d.pos - sam.pos;
let dist = rel.length();
if dist > RANGE {
return None;
}
let bearing = heading_of(rel);
(angle_diff(sam.heading, bearing).abs() <= SECTOR_HALF).then_some((dist, d.id))
})
.collect();
local.sort_by(|a, b| a.0.total_cmp(&b.0));
local.truncate(LOCAL_CANDIDATES);
local.first().map(|&(_, id)| id)
}
/// One tick of every optical post: age state, then spend the bounded line-of-sight budget.
/// It never writes a [`Track`] and never calls the enemy-intel emission channel.
pub(super) fn update_optics(&mut self, ground: &mut Ground) {
let now = self.tick;
let posts: Vec<usize> = self
.sams
.iter()
.enumerate()
.filter(|(_, s)| s.kind == SamKind::Optical)
.map(|(i, _)| i)
.collect();
if posts.is_empty() {
return;
}
let alive: std::collections::HashSet<u32> =
self.drones.iter().filter(|d| d.alive()).map(|d| d.id).collect();
for &i in &posts {
let sam = &mut self.sams[i];
if !sam.alive() || sam.moving() {
sam.optical.clear_activity();
continue;
}
if sam.part(Part::Sensor) <= 0.0 {
sam.optical.clear_activity();
sam.optical.state = OpticalState::NoSight;
sam.optical.block = Some(SightBlock::Sensor);
continue;
}
if let Some(id) = sam.optical.target() {
if !alive.contains(&id) {
sam.optical.drop_target();
}
}
if let Some(id) = sam.optical.commanded() {
if !alive.contains(&id) {
sam.optical.commanded = None;
}
}
// Searching posts keep their head turning; a post on a contact points at its forecast.
if let Some(id) = sam.optical.target() {
if let Some(d) = self.drones.iter().find(|d| d.id == id) {
sam.dish = heading_of(d.pos - sam.pos);
}
} else {
sam.dish = (sam.dish + 0.02) % TAU;
}
}
// Fair round-robin: a crowd of posts does not starve the last ones for ever.
let start = (now as usize) % posts.len();
let mut checks = 0usize;
for k in 0..posts.len() {
if checks >= CHECKS_PER_TICK {
break;
}
let i = posts[(start + k) % posts.len()];
let phase = (self.sams[i].id / PARTS) as u64 % PERIOD;
if now % PERIOD != phase {
continue;
}
let Some(target) = self.optical_target(i, now, &alive) else {
self.sams[i].optical.select(None);
continue;
};
if self.sams[i].optical.target() != Some(target) {
self.sams[i].optical.select(Some(target));
}
let sam = &self.sams[i];
let Some(d) = self.drones.iter().find(|d| d.id == target && d.alive()) else {
continue;
};
let from = sam.pos + DVec3::Y * MAST;
let to = d.pos;
let rel = to - from;
let range = rel.length();
let bearing = heading_of(to - sam.pos);
let night = self.night;
let sight = line_of_sight(ground, from, to, now, range, night);
checks += 1;
let sam = &mut self.sams[i];
sam.optical.checks += 1;
match sight {
Ok(()) => {
sam.optical.block = None;
sam.optical.seen = Some((target, d.pos, d.vel, now));
sam.optical.held = sam.optical.held.saturating_add(1);
let need = sam.optical.required(night);
if sam.optical.held >= need {
let samples = sam.optical.observations.saturating_add(1);
let observable = OpticalObservable { speed: d.vel.length(), climb: d.vel.y, range };
let observation = OpticalObservation {
target,
source: sam.id,
tick: now,
class: classify_optical(observable),
uncertainty: uncertainty(range, night, samples),
range,
bearing,
hold: sam.optical.held,
night,
};
sam.optical.held = 0;
sam.optical.observations = samples;
sam.optical.observation = Some(observation);
sam.optical.state = OpticalState::Observing;
} else {
sam.optical.state = if sam.optical.observation.is_some_and(|o| o.target == target) {
OpticalState::Observing
} else {
OpticalState::Holding
};
}
}
Err(block) => {
sam.optical.held = 0;
sam.optical.block = Some(block);
sam.optical.state = OpticalState::NoSight;
}
}
// The post's own state is `OpticalState`: it never claims a fire-control track.
sam.state = SamState::Search;
sam.optical.target = Some(target);
}
}
}
/// How unsure one observation is: range, night and the number of successful holds of the same contact.
fn uncertainty(range: f64, night: bool, samples: u32) -> f64 {
let r = (range / RANGE).clamp(0.0, 1.0);
let base = 0.10 + 0.55 * r + if night { 0.15 } else { 0.0 };
let refine = 0.85_f64.powi(samples.saturating_sub(1).min(3) as i32);
(base * refine).clamp(0.05, 0.95)
}
/// A bounded line of sight: land samples first, then one block probe. Unknown is never clear.
fn line_of_sight(ground: &mut Ground, from: DVec3, to: DVec3, now: u64, range: f64, night: bool) -> Result<(), SightBlock> {
if range > RANGE {
return Err(SightBlock::OutOfRange);
}
if night && range > NIGHT_RANGE {
return Err(SightBlock::Night);
}
for k in 1..TERRAIN_SAMPLES {
let t = k as f64 / TERRAIN_SAMPLES as f64;
let p = from + (to - from) * t;
let Some(g) = ground.land(DVec3::new(p.x, 0.0, p.z)) else {
return Err(SightBlock::UnknownGeometry);
};
if g > p.y - 0.8 {
return Err(SightBlock::Terrain);
}
}
match ground.world.probe(from, to, now) {
Sweep::Clear => Ok(()),
Sweep::Hit { .. } => Err(SightBlock::Obstacle),
Sweep::Unknown { .. } | Sweep::Wait { .. } => Err(SightBlock::UnknownGeometry),
}
}
#[cfg(test)]
mod tests {
use super::*;
use super::super::sight::Track;
fn optical_at(sim: &mut Sim, x: f64, z: f64, heading: f64) -> u32 {
let id = sim.id();
sim.sams.push(Sam::new(id, SamKind::Optical, DVec3::new(x, 70.0, z), heading));
id
}
/// Flat land at 70 and empty block sections along the line: a clear day.
fn clear_ground() -> Ground {
let mut ground = Ground::default();
let mut cols = Vec::new();
for x in -24..=24 {
for z in -180..=24 {
cols.push((x, z, 70));
}
}
ground.answer(cols, 0);
let mut answers = Vec::new();
for x in -1..=1 {
for y in 3..=7 {
for z in -12..=1 {
answers.push(world::SectionAnswer { sec: (x, y, z), fill: world::Fill::Empty });
}
}
}
ground.world.answer(answers, 0);
ground
}
fn flat_drone(sim: &mut Sim, kind: DroneKind, at: DVec3, vel: DVec3) -> u32 {
sim.add_drone(kind, at, DVec3::NEG_Z, at + DVec3::NEG_Z * 100.0);
let d = sim.drones.last_mut().unwrap();
d.pos = at;
d.vel = vel;
d.id
}
fn run(sim: &mut Sim, ground: &mut Ground, ticks: u64) {
for _ in 0..ticks {
sim.tick += 1;
sim.update_optics(ground);
}
}
// Day: one contact in the near sector is held and then classed. The source is the post itself.
#[test]
fn a_held_contact_gives_an_independent_class_observation() {
let mut sim = Sim::new(1);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
let id = flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -100.0), DVec3::new(0.5, 0.0, -0.6));
let mut ground = clear_ground();
run(&mut sim, &mut ground, 200);
let r = sim.optical_report(post).unwrap();
let obs = r.observation.expect("no class observation after a clear held contact");
assert_eq!(obs.source, post);
assert_eq!(obs.target, id);
assert_eq!(obs.class, Class::Drone);
assert!(obs.uncertainty < 0.5, "uncertainty {}", obs.uncertainty);
assert_eq!(r.state, OpticalState::Observing);
// Another successful hold is another independent observation: it refines, never re-measures a relay.
run(&mut sim, &mut ground, 250);
let later = sim.optical_report(post).unwrap();
let again = later.observation.unwrap();
assert!(again.tick > obs.tick && later.observations > 1);
assert!(again.uncertainty <= obs.uncertainty, "{} > {}", again.uncertainty, obs.uncertainty);
}
// Night blocks a contact beyond the reduced reach, and slows a close one: the day hold is not enough.
#[test]
fn night_shortens_the_reach_and_slows_the_hold() {
let mut sim = Sim::new(2);
sim.night = true;
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -200.0), DVec3::new(0.5, 0.0, -0.6));
let mut ground = clear_ground();
run(&mut sim, &mut ground, 200);
let r = sim.optical_report(post).unwrap();
assert_eq!(r.state, OpticalState::NoSight);
assert_eq!(r.block, Some(SightBlock::Night));
assert!(r.observation.is_none());
let mut close = Sim::new(3);
close.night = true;
let post = optical_at(&mut close, 0.0, 0.0, 0.0);
flat_drone(&mut close, DroneKind::Shahed, DVec3::new(0.0, 95.0, -100.0), DVec3::new(0.5, 0.0, -0.6));
let mut ground = clear_ground();
run(&mut close, &mut ground, HOLD_DAY as u64 * PERIOD as u64 + 10);
assert!(close.optical_report(post).unwrap().observation.is_none(), "a night hold was as quick as a day one");
run(&mut close, &mut ground, (HOLD_NIGHT - HOLD_DAY) as u64 * PERIOD as u64 + 20);
let r = close.optical_report(post).unwrap();
assert_eq!(r.state, OpticalState::Observing);
assert!(r.observation.is_some());
}
// A wall hides the contact; unknown block geometry is not a clean line of sight.
#[test]
fn a_wall_blocks_and_unknown_geometry_is_not_clear() {
let mut sim = Sim::new(4);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -100.0), DVec3::new(0.5, 0.0, -0.6));
let mut ground = clear_ground();
ground.world.answer(vec![world::SectionAnswer { sec: (0, 5, -4), fill: world::Fill::Full }], 0);
run(&mut sim, &mut ground, 200);
let r = sim.optical_report(post).unwrap();
assert_eq!(r.state, OpticalState::NoSight);
assert_eq!(r.block, Some(SightBlock::Obstacle));
assert!(r.observation.is_none());
// The same clear land and sky, but no answered sections: unknown, not clear.
let mut unknown = Sim::new(5);
let post = optical_at(&mut unknown, 0.0, 0.0, 0.0);
flat_drone(&mut unknown, DroneKind::Shahed, DVec3::new(0.0, 95.0, -100.0), DVec3::new(0.5, 0.0, -0.6));
let mut ground = Ground::default();
let mut cols = Vec::new();
for x in -24..=24 {
for z in -180..=24 {
cols.push((x, z, 70));
}
}
ground.answer(cols, 0);
run(&mut unknown, &mut ground, 200);
let r = unknown.optical_report(post).unwrap();
assert_eq!(r.block, Some(SightBlock::UnknownGeometry));
assert!(r.observation.is_none());
}
// Once the view is lost, the old observation only ages: no new observation is invented.
#[test]
fn an_old_observation_only_ages_after_the_view_is_lost() {
let mut sim = Sim::new(6);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -180.0), DVec3::new(0.5, 0.0, -0.6));
let mut ground = clear_ground();
run(&mut sim, &mut ground, 300);
let first = sim.optical_report(post).unwrap().observation.expect("no day observation");
let count = sim.optical_report(post).unwrap().observations;
sim.night = true;
run(&mut sim, &mut ground, 300);
let r = sim.optical_report(post).unwrap();
let last = r.observation.expect("the old observation was thrown away");
assert_eq!(last.tick, first.tick, "a new observation was invented while the view was lost");
assert_eq!(r.observations, count);
assert!(last.age(sim.tick) > 200);
assert_eq!(r.state, OpticalState::NoSight);
}
// The class comes from observable motion, never from DroneKind: two true models with the same
// pose and velocity get the same estimate and the same uncertainty.
#[test]
fn different_true_models_with_equal_observables_get_an_equal_estimate() {
fn observe(kind: DroneKind) -> (OpticalObservation, String) {
let mut sim = Sim::new(7);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
flat_drone(&mut sim, kind, DVec3::new(0.0, 95.0, -100.0), DVec3::new(0.9, 0.0, -0.9));
let mut ground = clear_ground();
run(&mut sim, &mut ground, 200);
let r = sim.optical_report(post).unwrap();
(r.observation.expect("no observation"), r.line())
}
let (a, text_a) = observe(DroneKind::Shahed);
let (b, text_b) = observe(DroneKind::Kinzhal);
assert_eq!((a.class, a.uncertainty), (b.class, b.uncertainty));
assert_eq!(a.class, Class::Jet);
for text in [text_a, text_b] {
assert!(!text.contains("Шахед") && !text.contains("Кинжал"), "{text}");
assert!(text.contains("оптический пост"), "{text}");
}
}
// A network cue only points the head; it is not a measurement and does not raise confidence.
#[test]
fn a_network_cue_is_not_a_measurement() {
let mut sim = Sim::new(8);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
let id = flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -500.0), DVec3::new(0.5, 0.0, -0.6));
sim.sams[0].tracks.push(Track {
id,
class: ClassEst::Probable(Class::Drone),
pos: sim.drones[0].pos,
vel: sim.drones[0].vel,
tick: 0,
own_tick: 0,
source: u32::MAX,
product: battery::Measure::Search,
quality: 60,
own_product: battery::Measure::Search,
own_quality: 0,
ttl: 100_000,
hits: 3,
locked: false,
});
let mut ground = clear_ground();
// The cue is fresh only for its `CUE_MAX_AGE`; the contact is beyond the optics' own reach.
run(&mut sim, &mut ground, 60);
let r = sim.optical_report(post).unwrap();
assert_eq!(r.target, Some(id));
assert_eq!(r.state, OpticalState::NoSight);
assert_eq!(r.block, Some(SightBlock::OutOfRange));
assert!(r.observation.is_none() && r.observations == 0, "a relayed track became a measurement");
}
// A manual priority selects exactly one contact and is kept while it lives.
#[test]
fn a_manual_priority_selects_one_contact() {
let mut sim = Sim::new(11);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
let near = flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -60.0), DVec3::new(0.5, 0.0, -0.6));
let far = flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -120.0), DVec3::new(0.5, 0.0, -0.6));
assert!(sim.assign_optical(post, Some(far)));
let mut ground = clear_ground();
run(&mut sim, &mut ground, 60);
let r = sim.optical_report(post).unwrap();
assert_eq!(r.target, Some(far));
assert!(sim.assign_optical(post, Some(near)));
run(&mut sim, &mut ground, 10);
assert_eq!(sim.optical_report(post).unwrap().target, Some(near));
assert!(!sim.assign_optical(post, Some(u32::MAX)), "a dead contact cannot be assigned");
}
// A failed optic is not a clear line: the state says so, and no observation is made.
#[test]
fn a_failed_sensor_stops_the_observation() {
let mut sim = Sim::new(12);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -100.0), DVec3::new(0.5, 0.0, -0.6));
sim.sams[0].comps.0[Part::Sensor as usize] = 0.0;
let mut ground = clear_ground();
run(&mut sim, &mut ground, 200);
let r = sim.optical_report(post).unwrap();
assert_eq!(r.state, OpticalState::NoSight);
assert_eq!(r.block, Some(SightBlock::Sensor));
assert!(r.observation.is_none());
}
// Work is bounded: many posts and many contacts still spend only the per-tick probe budget.
#[test]
fn many_posts_and_contacts_keep_the_los_budget_bounded() {
let mut sim = Sim::new(9);
for i in 0..32 {
optical_at(&mut sim, (i % 8) as f64 * 8.0, (i / 8) as f64 * 8.0, 0.0);
}
for i in 0..64 {
flat_drone(&mut sim, DroneKind::Shahed, DVec3::new((i % 8) as f64, 95.0, -60.0 - (i / 8) as f64 * 4.0), DVec3::new(0.5, 0.0, -0.6));
}
let mut ground = clear_ground();
sim.tick += 1;
sim.update_optics(&mut ground);
let checks: u64 = sim.sams.iter().filter(|s| s.kind == SamKind::Optical).map(|s| s.optical.checks()).sum();
assert!(checks > 0 && checks <= CHECKS_PER_TICK as u64, "checks {checks}");
}
// The post is passive: no radar emission, no own track, no enemy emission contact.
#[test]
fn the_post_never_emits_or_makes_a_fire_control_track() {
let mut sim = Sim::new(10);
let post = optical_at(&mut sim, 0.0, 0.0, 0.0);
flat_drone(&mut sim, DroneKind::Shahed, DVec3::new(0.0, 95.0, -100.0), DVec3::new(0.5, 0.0, -0.6));
let mut ground = clear_ground();
run(&mut sim, &mut ground, 200);
let sam = sim.sams.iter().find(|s| s.id == post).unwrap();
assert!(!sam.radar_up());
assert!(sam.own.is_empty());
assert!(sam.target.is_none() && sam.gun_target.is_none());
assert!(sam.tracks.is_empty());
assert!(sim.intel.contacts().is_empty(), "a passive post entered the enemy's emission picture");
}
}
+2 -2
View File
@@ -18,9 +18,9 @@ impl SamKind {
Family::Truck => 10,
}
}
/// A depot doesn't drive.
/// A depot and a fixed optical post don't drive.
pub fn mobile(self) -> bool {
self != SamKind::Depot
!matches!(self, SamKind::Depot | SamKind::Optical)
}
}
+3
View File
@@ -611,6 +611,9 @@ impl Sim {
}
}
}
// Passive optics (#136) look after the network has spoken: a cue is only a cue, and every
// observation it makes is its own, never a track and never an emission.
self.update_optics(ground);
}
/// Whether any system's radar holds this drone (the player's radar shows only those).
+28 -1
View File
@@ -380,6 +380,31 @@ const UNIT_SPEC_LIGHT: SamSpec = SamSpec {
mast: 1.5,
};
const UNIT_SPEC_OPTICAL: SamSpec = SamSpec {
name: "Оптический пост",
key: "optical",
missile: None,
gun: None,
reload: 0,
scale: 1.0,
rest_pitch: 0.0,
roles: 0,
family: Family::Static,
parts: Parts {
body: "airdef:radar_truck",
launcher: None,
pack: None,
dish: None,
fixed: &[],
spinner: Some(("airdef:radar_panel", 1.2, 0.0, 0.6, -0.2)),
},
mount: (0.0, 0.0),
pivot: DVec3::ZERO,
muzzle: Muzzle::None,
sensor: 0.0,
mast: 2.5,
};
impl SamKind {
/// Its row of numbers from `catalog/specs.json`.
pub fn spec(self) -> &'static SamSpec {
@@ -399,13 +424,14 @@ impl SamKind {
SamKind::Tzm => &UNIT_SPEC_TZM,
SamKind::Ew => &UNIT_SPEC_EW,
SamKind::Light => &UNIT_SPEC_LIGHT,
SamKind::Optical => &UNIT_SPEC_OPTICAL,
}
}
}
/// Save keys by kind; a rename needs an explicit migration.
#[cfg(test)]
pub(super) const UNIT_SPEC_KEYS: [(SamKind, &str); 15] = [
pub(super) const UNIT_SPEC_KEYS: [(SamKind, &str); 16] = [
(SamKind::Patriot, "patriot"),
(SamKind::Gepard, "gepard"),
(SamKind::Pantsir, "pantsir"),
@@ -421,4 +447,5 @@ pub(super) const UNIT_SPEC_KEYS: [(SamKind, &str); 15] = [
(SamKind::Tzm, "tzm"),
(SamKind::Ew, "ew"),
(SamKind::Light, "light"),
(SamKind::Optical, "optical"),
];
+2
View File
@@ -27,6 +27,8 @@ pub enum SamKind {
Ew,
/// A searchlight: lights up targets at night for the guns.
Light,
/// A passive optical observation post: no radar, no weapon, one class observation at a time (#136).
Optical,
}
/// How a vehicle is put together: how its launcher or turret moves and is drawn.
+10 -3
View File
@@ -179,14 +179,21 @@ mod catalog_tests {
}
fn item_exists(item: &str) {
let name = item.strip_prefix("airdef:").expect("item namespace");
for path in [format!("items/{name}.json"), format!("models/item/{name}.json"), format!("textures/item/{name}.png")] {
for path in [format!("items/{name}.json"), format!("models/item/{name}.json")] {
assert!(assets().join(&path).is_file(), "{item}: missing {path}");
}
let definition = std::fs::read_to_string(assets().join(format!("items/{name}.json"))).unwrap();
assert!(definition.contains(&format!("airdef:item/{name}")), "{item}: wrong item model");
let model = std::fs::read_to_string(assets().join(format!("models/item/{name}.json"))).unwrap();
assert!(model.contains(&format!("airdef:item/{name}")), "{item}: wrong icon reference");
let png = std::fs::read(assets().join(format!("textures/item/{name}.png"))).unwrap();
// The icon reference may be an alias of an existing texture (the optical post uses the
// radar icon until its own asset lands, #136); what matters is that the PNG it names exists.
let layer = model
.split("\"layer0\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or_else(|| panic!("{item}: no icon reference"));
let texture = layer.strip_prefix("airdef:item/").unwrap_or_else(|| panic!("{item}: bad icon reference {layer}"));
let png = std::fs::read(assets().join(format!("textures/item/{texture}.png"))).unwrap();
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"), "{item}: invalid PNG signature");
}
fn model_exists(model: &str) {
+13
View File
@@ -126,6 +126,10 @@
{
"kind": "Light",
"item": "deploy_light"
},
{
"kind": "Optical",
"item": "deploy_optical"
}
],
"variants": [
@@ -405,6 +409,15 @@
52
]
},
{
"id": "deploy_optical",
"title": "Развернуть оптический пост",
"color": [
70,
110,
90
]
},
{
"id": "mover",
"title": "Пульт перемещения",
+25
View File
@@ -668,6 +668,31 @@
"muzzle": {"type": "none"},
"sensor": 0.0,
"mast": 1.5
},
{
"kind": "Optical",
"key": "optical",
"name": "Оптический пост",
"missile": null,
"gun": null,
"reload": 0,
"scale": 1.0,
"rest_pitch": 0.0,
"roles": 0,
"family": "static",
"parts": {
"body": "airdef:radar_truck",
"launcher": null,
"pack": null,
"dish": null,
"fixed": [],
"spinner": ["airdef:radar_panel", 1.2, 0.0, 0.6, -0.2]
},
"mount": [0.0, 0.0],
"pivot": [0.0, 0.0, 0.0],
"muzzle": {"type": "none"},
"sensor": 0.0,
"mast": 2.5
}
],
"missiles": [
+2
View File
@@ -339,6 +339,8 @@ ICON_DRAW = {
"deploy_radar": _radar, "deploy_ew": _ew,
"deploy_depot": _depot, "deploy_tzm": _tzm,
"deploy_light": _searchlight,
# Temporary placeholder until the optical post has its own icon (#136).
"deploy_optical": _radar,
"mover": _mover, "remover": _remover, "flare_gun": _flare,
}