diff --git a/airdef-mod/src/battery_view.rs b/airdef-mod/src/battery_view.rs index d9844b7..77659c9 100644 --- a/airdef-mod/src/battery_view.rs +++ b/airdef-mod/src/battery_view.rs @@ -39,7 +39,7 @@ pub fn status(status: BatteryStatus) -> String { } /// One system's line in the summary panel and on the map. -pub fn sam_status(sam: &Sam) -> String { +pub fn sam_status(sam: &Sam, now: u64) -> String { let spec = sam.kind.spec(); let mut text = spec.name.to_string(); if !sam.alive() { @@ -67,7 +67,7 @@ pub fn sam_status(sam: &Sam) -> String { let channels = if profile.channels == 0 { "без уточнения".to_string() } else { - format!("каналы {}/{}", sam.own_channels_used(), profile.channels) + format!("каналы {}/{}", sam.own_channels_used(now), profile.channels) }; return format!("{text} «{}»: {}; целей {}{broken}, {channels}", profile.name, profile.products_text(), sam.own.len()); } @@ -126,20 +126,20 @@ mod tests { let mut s400 = Sam::new(1, SamKind::S400, DVec3::ZERO, 0.0); s400.missiles = 1; s400.ground_rounds = 2; - assert_eq!(sam_status(&s400), "С-400 ПВО 1 · RM48U 2 / 4 ячеек"); + assert_eq!(sam_status(&s400, 0), "С-400 ПВО 1 · RM48U 2 / 4 ячеек"); s400.ground_return = true; - assert_eq!(sam_status(&s400), "С-400 ПВО 1 · RM48U 2 / 4 ячеек · ожидает вывоза RM48U"); + assert_eq!(sam_status(&s400, 0), "С-400 ПВО 1 · RM48U 2 / 4 ячеек · ожидает вывоза RM48U"); let mut pantsir = Sam::new(2, SamKind::Pantsir, DVec3::ZERO, 0.0); pantsir.missiles = 7; pantsir.bursts = 100; - assert_eq!(sam_status(&pantsir), "Панцирь-С1 ракеты 7/12 очереди 100"); + assert_eq!(sam_status(&pantsir, 0), "Панцирь-С1 ракеты 7/12 очереди 100"); let mut worn = Sam::new(3, SamKind::Patriot, DVec3::ZERO, 0.0); worn.health = 0.5; worn.comps.0[Part::Sensor as usize] = 0.4; worn.reloading = 21; - assert_eq!(sam_status(&worn), "Patriot (50%) [РЛС 40%] перезарядка 2с"); + assert_eq!(sam_status(&worn, 0), "Patriot (50%) [РЛС 40%] перезарядка 2с"); } #[test] @@ -147,41 +147,41 @@ mod tests { let mut radar = Sam::new(4, SamKind::Radar, DVec3::ZERO, 0.0); radar.own.push(7); radar.comps.0[Part::Sensor as usize] = 0.0; - assert_eq!(sam_status(&radar), "РЛС дальнего обнаружения «многофункциональная»: обзор, уточнение, пуск; целей 1 [РЛС отказ], каналы 0/3"); + assert_eq!(sam_status(&radar, 0), "РЛС дальнего обнаружения «многофункциональная»: обзор, уточнение, пуск; целей 1 [РЛС отказ], каналы 0/3"); let mut depot = Sam::new(5, SamKind::Depot, DVec3::ZERO, 0.0); depot.cargo = 2; depot.ground_stock = 3; depot.air_48n6_stock = 1; - assert_eq!(sam_status(&depot), "Склад боеприпасов: 2 перезарядок, RM48U 3, снятых ПВО 1"); + assert_eq!(sam_status(&depot, 0), "Склад боеприпасов: 2 перезарядок, RM48U 3, снятых ПВО 1"); let mut tzm = Sam::new(6, SamKind::Tzm, DVec3::ZERO, 0.0); tzm.cargo = 1; tzm.return_cargo = true; - assert_eq!(sam_status(&tzm), "ТЗМ: на борту 1/2, RM48U 0, снятых ПВО 0, везёт RM48U на склад"); + assert_eq!(sam_status(&tzm, 0), "ТЗМ: на борту 1/2, RM48U 0, снятых ПВО 0, везёт RM48U на склад"); let mut ew = Sam::new(7, SamKind::Ew, DVec3::ZERO, 0.0); ew.ew_on = true; ew.heat = 0.5; - assert_eq!(sam_status(&ew), "Станция РЭБ: ГЛУШИТ, нагрев 50%"); + assert_eq!(sam_status(&ew, 0), "Станция РЭБ: ГЛУШИТ, нагрев 50%"); let mut light = Sam::new(8, SamKind::Light, DVec3::ZERO, 0.0); light.target = Some(1); - assert_eq!(sam_status(&light), "Прожектор: в луче цель"); + assert_eq!(sam_status(&light, 0), "Прожектор: в луче цель"); let optical = Sam::new(9, SamKind::Optical, DVec3::ZERO, 0.0); - assert_eq!(sam_status(&optical), "Оптический пост: ищет"); + assert_eq!(sam_status(&optical, 0), "Оптический пост: ищет"); } #[test] fn renders_moving_and_destroyed_systems_in_existing_format() { let mut moving = Sam::new(9, SamKind::S400, DVec3::ZERO, 0.0); moving.state = SamState::Moving; - assert_eq!(sam_status(&moving), "С-400 на марше"); + assert_eq!(sam_status(&moving, 0), "С-400 на марше"); let mut dead = Sam::new(10, SamKind::S400, DVec3::ZERO, 0.0); dead.health = 0.0; - assert_eq!(sam_status(&dead), "С-400 УНИЧТОЖЕН"); + assert_eq!(sam_status(&dead, 0), "С-400 УНИЧТОЖЕН"); } #[test] diff --git a/airdef-mod/src/map.rs b/airdef-mod/src/map.rs index e98ef46..cbe5ec6 100644 --- a/airdef-mod/src/map.rs +++ b/airdef-mod/src/map.rs @@ -2732,7 +2732,7 @@ impl AirDef { lines.push((format!("Профиль РЛС: {} [{}]", profile.name, profile.id), WHITE)); lines.push((crate::battery_view::radar_profile_line(profile), GREY)); lines.push((format!("Ограничение: {}", profile.limit), GREY)); - lines.push((format!("Каналы: {}/{} · профиль задан при размещении", sam.own_channels_used(), profile.channels), GREY)); + lines.push((format!("Каналы: {}/{} · профиль задан при размещении", sam.own_channels_used(now), profile.channels), GREY)); } else if sam.mode == sim::battery::SamMode::LauncherOnly { lines.push(("Отдельная пусковая: внешняя РЛС сопровождения".into(), WHITE)); } @@ -2740,7 +2740,7 @@ impl AirDef { lines.push((format!("Излучение РЛС: {}", if sam.radar_on { "вкл" } else { "выкл" }), WHITE)); btns.push((if sam.radar_on { "Выключить РЛС" } else { "Включить РЛС" }.into(), Act::RadarEmission, sam.radar_on)); } - lines.push((crate::battery_view::sam_status(sam), WHITE)); + lines.push((crate::battery_view::sam_status(sam, now), WHITE)); if k == SamKind::Optical && let Some(r) = self.sim.optical_report(sam.id) { diff --git a/airdef-mod/src/monitor.rs b/airdef-mod/src/monitor.rs index a03c5be..5f921b3 100644 --- a/airdef-mod/src/monitor.rs +++ b/airdef-mod/src/monitor.rs @@ -189,7 +189,7 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec Vec { } for sam in sim.sams.iter().take(shown) { let mut text = if sam.kind.armed() { - format!("{} [{}]", crate::battery_view::sam_status(sam), crate::sim::roles_text(sam.roles)) + format!("{} [{}]", crate::battery_view::sam_status(sam, now), crate::sim::roles_text(sam.roles)) } else { - crate::battery_view::sam_status(sam) + crate::battery_view::sam_status(sam, now) }; if let Some(t) = sam.gun_target.or(sam.target).and_then(|t| pic.get(t)) { text += &format!(" > {} {}", t.class.name(), distance(t.est(now).distance(sam.pos))); diff --git a/airdef-mod/src/sim/sensor_tests.rs b/airdef-mod/src/sim/sensor_tests.rs index cad2577..a5166a7 100644 --- a/airdef-mod/src/sim/sensor_tests.rs +++ b/airdef-mod/src/sim/sensor_tests.rs @@ -496,7 +496,7 @@ fn run_profile_world(roles: &[RadarRole], ticks: u64) -> (ProfileStats, Sim, Vec if sam.radar_profile().id == "radar_search" || sam.radar_profile().id == "radar_height" { stats.search_or_height_authorized |= sam.tracks.iter().any(|t| t.own_authorizes(sim.tick)); } - stats.max_channels = stats.max_channels.max(sam.own_channels_used()); + stats.max_channels = stats.max_channels.max(sam.own_channels_used(sim.tick)); } } (stats, sim, radars, ids) @@ -633,11 +633,65 @@ fn tracked_channels_are_a_hard_limit_but_the_rest_keep_search_plots() { let own: Vec<&Track> = sim.sams[engagement].tracks.iter().filter(|t| t.own_tick > 0).collect(); let precise = own.iter().filter(|t| t.own_product != Measure::Search).count(); assert_eq!(precise, 2, "the station refined more contacts than its channels: {own:?}"); - assert_eq!(sim.sams[engagement].own_channels_used(), 2); + assert_eq!(sim.sams[engagement].own_channels_used(sim.tick), 2); assert_eq!(own.len(), 4, "a full station stopped giving coarse search plots: {own:?}"); assert!(own.iter().filter(|t| t.own_product == Measure::Search).all(|t| !t.own_authorizes(sim.tick))); } +// #140: a network heartbeat keeps an old contact's track fresh, but never holds the station's +// channel: two stale own fire plots free the channels for a new contact, and the survey tracks +// of the old ones stay on the picture — with the search radar left running. +#[test] +fn stale_own_plots_free_their_channels_while_the_network_keeps_the_tracks() { + let mut sim = Sim::new(140); + let engagement = radar_with_role(&mut sim, RadarRole::Engagement, 0.0); + let search = radar_with_role(&mut sim, RadarRole::Search, 1550.0); + for x in [100.0, 140.0] { + sim.add_drone(DroneKind::Gerbera, DVec3::new(x, 120.0, 0.0), DVec3::Z, DVec3::new(x, 120.0, 0.0)); + } + let old: Vec = sim.drones.iter().map(|d| d.id).collect(); + let mut ground = Ground::default(); + let radars = [engagement, search]; + for tick in 1..=40 { + let targets: Vec = sim.drones.iter().map(|d| d.pos).collect(); + sweep(&mut sim, &mut ground, &radars, &targets, tick); + } + let frozen: Vec = old + .iter() + .map(|&id| { + let t = sim.sams[engagement].track(id).expect("the station took the contact"); + assert_ne!(t.own_product, Measure::Search, "the station took no channel: {t:?}"); + t.own_tick + }) + .collect(); + assert_eq!(sim.sams[engagement].own_channels_used(sim.tick), 2); + // The two contacts leave the station's reach for the search radar beside them; the new one + // arrives close to the station. Only the network keeps the old tracks alive now. + for (k, d) in sim.drones.iter_mut().enumerate() { + d.pos = DVec3::new(1600.0 + 20.0 * k as f64, 120.0, 0.0); + } + sim.add_drone(DroneKind::Gerbera, DVec3::new(180.0, 120.0, 0.0), DVec3::Z, DVec3::new(180.0, 120.0, 0.0)); + let fresh = sim.drones.last().unwrap().id; + for tick in 41..=750 { + let targets: Vec = sim.drones.iter().map(|d| d.pos).collect(); + sweep(&mut sim, &mut ground, &radars, &targets, tick); + } + let now = sim.tick; + let station = &sim.sams[engagement]; + assert_eq!(station.own_channels_used(now), 1, "the stale channels still hold: {:?}", station.tracks); + for (&id, &own_tick) in old.iter().zip(&frozen) { + let t = station.track(id).expect("the survey track was thrown away with its channel"); + assert_eq!(t.own_tick, own_tick, "the network renewed the station's own plot"); + assert!(t.tick > 500, "the network stopped relaying the old contact: {t:?}"); + assert_eq!(t.product, Measure::Search, "the relayed survey plot is gone: {t:?}"); + assert!(!t.holds_channel(now, station.track_ttl() as u64), "an old own plot still holds a channel: {t:?}"); + assert!(!t.own_authorizes(now)); + } + let new = station.track(fresh).expect("the new contact is not held"); + assert_eq!(new.own_product, Measure::Fire, "the new contact never got a channel: {new:?}"); + assert!(new.own_authorizes(now), "the new contact's own fire plot does not authorize: {new:?}"); +} + #[test] fn off_and_damage_remove_the_station_and_its_quality_without_touching_neighbours() { let mut sim = Sim::new(1342); @@ -751,7 +805,7 @@ fn profiles_keep_their_jobs_over_a_ridge_on_one_seed_and_land() { stats.high_marked |= t.id == ids[1]; } if profile.id == "radar_track" { - stats.track_channels = stats.track_channels.max(sam.own_channels_used()); + stats.track_channels = stats.track_channels.max(sam.own_channels_used(sim.tick)); } if profile.id == "radar_search" || profile.id == "radar_height" { stats.nonfire_authorized |= sam.tracks.iter().any(|t| t.own_authorizes(sim.tick)); diff --git a/airdef-mod/src/sim/sight.rs b/airdef-mod/src/sim/sight.rs index 5cff4da..3291b07 100644 --- a/airdef-mod/src/sim/sight.rs +++ b/airdef-mod/src/sim/sight.rs @@ -322,6 +322,15 @@ impl Track { pub fn own_authorizes(&self, now: u64) -> bool { self.own_fire_within(now, MISSILE_AGE) } + /// The station's own refine/fire channel on this contact is still live: the plot is its own, + /// finer than a search, and no older than the station keeps a contact without a fresh + /// measurement. A relayed plot never holds a channel: the network's heartbeat keeps the + /// track fresh, not the station's own tracking (#140). + pub fn holds_channel(&self, now: u64, ttl: u64) -> bool { + self.own_tick > 0 + && self.own_product != battery::Measure::Search + && now.saturating_sub(self.own_tick) <= ttl + } /// Who measured the latest plot, as an ID (`0`: no station). pub fn measured_by(&self) -> Option { (self.source != 0).then_some(self.source) @@ -371,9 +380,15 @@ impl Sam { pub fn track(&self, id: u32) -> Option<&Track> { self.tracks.iter().find(|t| t.id == id) } - /// Refined/fire channels this station is currently using. - pub fn own_channels_used(&self) -> usize { - self.tracks.iter().filter(|t| t.own_tick > 0 && t.own_product != battery::Measure::Search).count() + /// Ticks a contact stays this station's own without a fresh measurement: three missed turns, at least 60. + pub(super) fn track_ttl(&self) -> u32 { + ((self.scan_ticks() * 3.0) as u32).max(60) + } + /// Refined/fire channels this station is currently using: the same test the planner applies, + /// so the panel and the allocation never disagree about a stale channel. + pub fn own_channels_used(&self, now: u64) -> usize { + let ttl = self.track_ttl() as u64; + self.tracks.iter().filter(|t| t.holds_channel(now, ttl)).count() } } @@ -473,13 +488,14 @@ impl Sim { let scan = sam.scan_profile(); let period = sam.scan_ticks(); let w = TAU / period; - let (b0, ttl) = (sam.beam, ((period * 3.0) as u32).max(60)); + let (b0, ttl) = (sam.beam, sam.track_ttl()); sam.beam = (b0 + w) % TAU; let at = antenna(sam); let horizon = self.horizons.get(&sam.id); let local = spec.sensor * profile.local; - // Channels already refining or holding fire plots. Search plots do not use one. - let mut used = sam.tracks.iter().filter(|t| t.own_tick > 0 && t.own_product != battery::Measure::Search).count(); + // Channels already refining or holding fire plots, by the same test the UI shows: + // a stale own plot (the network may keep the track) no longer occupies one. + let mut used = sam.own_channels_used(now); let mut fresh: Vec = Vec::new(); for (d, h) in self.drones.iter().zip(&heights) { if !d.alive() { @@ -511,8 +527,7 @@ impl Sim { // and a full station does not silently refine the whole sky. A station already // refining a contact keeps its channel; a new refinement needs a free one, and // without one the station still publishes its ordinary coarse search plot. - let own_held = held.is_some_and(|t| t.own_tick > 0); - let holds_channel = own_held && held.is_some_and(|t| t.own_product != battery::Measure::Search); + let holds_channel = held.is_some_and(|t| t.holds_channel(now, ttl as u64)); let mut product = if profile.allows(battery::Measure::Fire) { battery::Measure::Fire } else if profile.allows(battery::Measure::Refine) && held.is_some() { diff --git a/airdef-mod/src/sim/why.rs b/airdef-mod/src/sim/why.rs index 43f758c..63a4712 100644 --- a/airdef-mod/src/sim/why.rs +++ b/airdef-mod/src/sim/why.rs @@ -423,7 +423,7 @@ impl Sim { let spec = sam.kind.spec(); let now = self.tick; let channels = (spec.sensor > 0.0 && sam.mode != battery::SamMode::LauncherOnly && sam.radar_profile().channels > 0) - .then(|| (sam.own_channels_used(), sam.radar_profile().channels)); + .then(|| (sam.own_channels_used(now), sam.radar_profile().channels)); let reason = |kind, block, target, mark| BattleReason { kind, block, @@ -554,7 +554,7 @@ impl Sim { }); if let Some((radar, tr)) = support { let profile = radar.radar_profile(); - let used = radar.own_channels_used(); + let used = radar.own_channels_used(now); if profile.channels > 0 && used >= profile.channels as usize && !tr.own_authorizes(now) { let mut busy = reason(BattleKind::ChannelsBusy, None, Some(t.id), mark); busy.channels = Some((used, profile.channels)); @@ -667,8 +667,8 @@ impl Sim { if profile.local >= 1.0 { "во всей дальности".to_string() } else { format!("{:.0}% дальности", profile.local * 100.0) }, ))); v.push(check(true, format!("ограничение: {}", profile.limit))); - v.push(check(true, format!("свои треки: {}, каналы {}/{}", sam.own.len(), sam.own_channels_used(), profile.channels))); let now = self.tick; + v.push(check(true, format!("свои треки: {}, каналы {}/{}", sam.own.len(), sam.own_channels_used(now), profile.channels))); let mut tracks: Vec<&Track> = sam.tracks.iter().filter(|t| t.own_tick > 0).collect(); tracks.sort_by_key(|t| std::cmp::Reverse(t.quality)); for t in tracks.into_iter().take(4) { diff --git a/docs/BATTERIES-AND-COLD-LAUNCH.md b/docs/BATTERIES-AND-COLD-LAUNCH.md index c7df476..3fbc057 100644 --- a/docs/BATTERIES-AND-COLD-LAUNCH.md +++ b/docs/BATTERIES-AND-COLD-LAUNCH.md @@ -65,7 +65,9 @@ Сеть передаёт трек вместе с измерившей станцией, возрастом и качеством. Повторная пересылка не освежает измерение и не создаёт права на пуск. Уточнение применяется только к сопоставленному -контакту, а число каналов ограничено на каждом тике. Если РЛС сопровождения уничтожена, свёрнута, +контакту, а число каналов ограничено на каждом тике. Канал удерживает только собственное измерение +станции: когда оно устаревает (станция больше не измеряет контакт), канал освобождается для новой +цели, а сетевой обзорный трек остаётся на месте. Если РЛС сопровождения уничтожена, свёрнута, потеряла связь или её измерение устарело, новые пуски прекращаются. Уже вылетевшие ракеты продолжают штатную игровую логику связи/памяти/самонаведения.