Add typed battle reasons and short engagement chains (#148)
build / mod (push) Failing after 32s
build / mod (push) Failing after 32s
A battery's "why" now starts with one typed reason shared by the monitor, the HUD and the chat: only observation, waiting for a track, busy channels, no ammunition, or ready. It carries the age and the station of the mark it is about, and `/airdef why <n> source` moves the monitor to that station. The reason is computed from the same predicates the launch decision uses, and the detailed decision settles it, so a headline cannot promise or deny a shot the simulation does not take. The after-action review builds 4-5 measured steps per contact from the recording's scene journal and events: mark, handoff, lock, launch, outcome. The menu lists them per battery with a filter and opens a replay frame on a click (the outcome clip, else the map held at the launch or mark); `/airdef chains [battery]` prints the same list. Missing transitions stay missing and marked as no launch, never guessed, and the normal HUD still shows only the battery's own picture. Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
@@ -206,7 +206,12 @@ API 31 форка) и следуют за взглядом покадрово;
|
||||
целью, потом за перехватчиком (или смотрит из пушки, со стороны на прилёт), в момент сбития время замедляется;
|
||||
- **полный повтор** — весь налёт, камера-режиссёр сама выбирает, за чем следить; колесо — перемотка, стрелки — скорость;
|
||||
- **лучшие моменты** — нарезка до 8 самых интересных событий (перехват баллистики и гиперзвука, поражения
|
||||
объектов, потерянные комплексы, разделение «Орешника») с титрами и замедлением; колесо листает моменты.
|
||||
объектов, потерянные комплексы, разделение «Орешника») с титрами и замедлением; колесо листает моменты;
|
||||
- **цепочки боя** — меню N → «Повторы…» → «Цепочки боя»: по каждому контакту короткая строка
|
||||
«отметка → передача → захват → пуск → исход» из 4–5 измеренных переходов записи, без домыслов. Видны
|
||||
время каждого шага, батарея и контакт, у пропущенных контактов — «без пуска». Фильтр по батарее
|
||||
переключает список; клик открывает кадр повтора (клип исхода, а если исхода нет — карту налёта на
|
||||
моменте пуска или отметки). То же списком: `/airdef chains [номер батареи]`.
|
||||
|
||||
Повтор идёт на весь экран с леттербоксом; звук слышен так, как его слышала бы камера. Управление (подсказка
|
||||
показывается в начале, после нажатия и на паузе): **← →** — перемотка на 5 с (в нарезке — соседний момент),
|
||||
@@ -232,6 +237,18 @@ API 31 форка) и следуют за взглядом покадрово;
|
||||
- `/airdef deploy s400_launcher` и `s500_launcher` — отдельные пусковые без своей РЛС; `radar_search`, `radar_track`, `radar_height` — три разные игровые РЛС с устойчивыми профилями в каталоге. Они также доступны через меню N → «Разместить элементы батареи…». `/airdef battery` показывает состав, профиль, цикл, продукты измерения и связь; `/airdef battery <номер> integrated|launcher` меняет конфигурацию. Профиль РЛС задаётся при размещении и не переключается на ходу: `radar <номер> on|off` сохраняется. Обзорная станция даёт редкие грубые отметки и область поиска; мачтовая уточняет низкие контакты над рельефом; сопровождения ищет локально, ведёт ограниченное число точных треков и только её собственное подтверждённое измерение разрешает пуск. Сеть передаёт источник, возраст и качество, но повторная пересылка не освежает измерение. Старые С-400/С-500 сохраняют сборную конфигурацию, старые роли РЛС при загрузке сопоставляются с профилями. [Устройство игровой батареи и пуска](docs/BATTERIES-AND-COLD-LAUNCH.md).
|
||||
- `/airdef roles` — показать, по каким классам целей работает каждый комплекс; `/airdef roles <patriot|gepard|pantsir|s400|s500|all> <классы|default>` — задать (классы через запятую: `drone`, `jet`, `cruise`, `supersonic`, `ballistic` или `all`), например `/airdef roles s400 cruise,ballistic`;
|
||||
- `/airdef doctrine` — доктрины комплексов (#47; в меню N: «Доктрины…»): `/airdef doctrine <номер|all> reserve <K>` — держать K ракет для срочных целей (баллистика или до удара меньше 12 с); `salvo eco|normal|heavy` — сколько перехватчиков на цель (только базовые / как обычно / на один больше); `sector <центр°> <полуширина°>` или `sector off` — сектор ответственности (0° — север); `guard <объект№>[,<№>]` или `guard off` — стрелять только по тому, что идёт на охраняемые объекты (отметка: `/airdef target here`). По умолчанию ограничений нет; последний шанс сильнее доктрины; `/airdef why <номер>` называет, какая настройка остановила или разрешила пуск; сохраняется с миром и сценариями. Карта охраны и пробелов в ней — вместе с картой (#48).
|
||||
- `/airdef why <номер>` — почему комплекс стреляет или нет. Сразу под строкой состояния — одна typed-причина:
|
||||
«есть только обзор», «ждёт сопровождения», «каналы заняты», «нет боезапаса» или «готов к пуску», вместе с возрастом и
|
||||
источником отметки (своя РЛС или сеть, РЛС №N). «Есть только обзор» — на картине лишь поисковая или
|
||||
сетевая отметка, своё подтверждённое измерение пуск не разрешает; «ждёт сопровождения» — своя РЛС ещё
|
||||
уточняет контакт или пусковая ждёт огневой трек поддерживающей РЛС; «каналы заняты» — все каналы
|
||||
сопровождения заняты другими контактами; «нет боезапаса» — нет ракет и снарядов или идёт перезарядка.
|
||||
`/airdef why <номер> source` переводит монитор K на станцию, которая поставила отметку. Подробные
|
||||
проверки (роли, доктрина, дальность, наведение) идут ниже и не расходятся с этой причиной. В обычном
|
||||
HUD — только картина самой батареи: класс по оценке, без истинного типа и скрытых данных.
|
||||
- `/airdef chains [номер батареи]` — короткие цепочки последнего налёта: «отметка → передача → захват →
|
||||
пуск → исход» с временем шагов; без номера — все батареи. Строка кликабельна в меню N → «Повторы…» →
|
||||
«Цепочки боя» и открывает кадр повтора.
|
||||
- `/airdef deploy <patriot|gepard|pantsir|s400|s500>` — поставить комплекс в 8 блоках перед собой;
|
||||
- `/airdef hold on|off` — запретить или разрешить ПВО огонь, удобно для съёмки ударов;
|
||||
- `/airdef damage on|off` — разрушать ли ландшафт взрывами (через TNT, нужны читы);
|
||||
|
||||
@@ -57,7 +57,10 @@ pub fn tree() -> Tree {
|
||||
Node::lit("list").runs(),
|
||||
Node::lit("delete").then(Node::arg("имя", Value::names(SCENARIOS)).runs()),
|
||||
]),
|
||||
Node::lit("why").runs().then(Node::arg("номер", Value::int_from(1)).runs()),
|
||||
Node::lit("why").runs().then(
|
||||
Node::arg("номер", Value::int_from(1)).runs().then(Node::lit("source").runs()),
|
||||
),
|
||||
Node::lit("chains").runs().then(Node::arg("батарея", Value::int_from(1)).runs()),
|
||||
Node::lit("raid").runs(),
|
||||
Node::lit("sites").runs(),
|
||||
Node::lit("ground-stock").then(Node::arg("склад", Value::int_from(1)).then(Node::arg("количество", Value::int_from(0)).runs())),
|
||||
@@ -168,7 +171,7 @@ mod tests {
|
||||
"replay film 3", "replay export", "replay export mine", "replay export best", "replay export all", "replay export 3",
|
||||
"replay export mine all fps=30 size=1280x720 crf=18 sec=12.5 noaudio", "replay export fps=60", "replay stop",
|
||||
"scenario save a", "scenario save a fresh", "scenario load a", "scenario load a force", "scenario list",
|
||||
"scenario delete a", "why", "why 2", "ew on", "ew off", "move 4", "target here", "targets clear",
|
||||
"scenario delete a", "why", "why 2", "why 2 source", "chains", "chains 2", "ew on", "ew off", "move 4", "target here", "targets clear",
|
||||
"sites", "strike 3", "battery", "battery 1 launcher", "battery 1 integrated", "radar 2 on", "radar 2 off", "radar 2 engagement", "radar 2 search", "deploy s400_launcher", "deploy s500_launcher", "deploy radar_search", "deploy radar_track", "deploy radar_height", "deploy patriot", "deploy light", "deploy s400", "wave mix", "wave shahed", "wave shahed 20", "wave kh101 80 800", "wave shahed 20 4000",
|
||||
"wave oreshnik 1 60", "damage on", "damage off", "truth on", "shader hd", "shader off", "shader on", "hold on", "lastchance on", "lastchance off",
|
||||
"roles all default", "doctrine", "doctrine 1 reserve 4", "doctrine all salvo eco", "doctrine 2 sector 90 45", "doctrine 2 sector off", "doctrine 1 guard 1,2", "doctrine 1 reset", "roles patriot drone,jet", "roles pantsir all", "roles tor ballistic",
|
||||
@@ -242,10 +245,10 @@ mod tests {
|
||||
fn completion_offers_the_next_word_only() {
|
||||
let top = complete("", &[]);
|
||||
for w in ["menu", "monitor", "grid", "replay", "scenario", "why", "raid", "repair", "import", "ew", "flare", "move",
|
||||
"target", "give", "deploy", "wave", "clear", "targets", "damage", "truth", "shader", "hold", "lastchance", "roles", "doctrine", "stats", "recon", "sites", "strike", "ground-stock", "ground-load", "ground-unload", "ground-cancel"] {
|
||||
"target", "give", "deploy", "wave", "clear", "targets", "damage", "truth", "shader", "hold", "lastchance", "roles", "doctrine", "stats", "recon", "sites", "strike", "ground-stock", "ground-load", "ground-unload", "ground-cancel", "chains"] {
|
||||
assert!(top.contains(&w.to_string()), "{w} in {top:?}");
|
||||
}
|
||||
assert_eq!(top.len(), 36);
|
||||
assert_eq!(top.len(), 37);
|
||||
assert_eq!(complete("rep", &[]), ["repair", "replay"]);
|
||||
assert_eq!(complete("replay ", &[]), ["export", "film", "full", "map", "reel", "stop"]);
|
||||
assert_eq!(complete("replay film ", &[]), ["all", "best"]);
|
||||
|
||||
@@ -79,6 +79,8 @@ struct AirDef {
|
||||
health_mark: u64,
|
||||
/// The menu's page while it is open.
|
||||
menu: Option<Page>,
|
||||
/// The battery the after-action chain list is filtered to (its id; None: all).
|
||||
chain_filter: Option<u32>,
|
||||
/// Where the player is, for the sounds' delay and far variants.
|
||||
listener: DVec3,
|
||||
/// The picture punch (#51) the HD exposure and bloom were last set for.
|
||||
@@ -206,6 +208,8 @@ enum Page {
|
||||
More,
|
||||
/// The last raid's events and its replays.
|
||||
Replays,
|
||||
/// The last raid's short battle chains: mark → handoff → lock → launch → outcome (#148).
|
||||
Chains,
|
||||
/// The enemy's recon picture and why it prices each mark: debug and after-action review (#135).
|
||||
Recon,
|
||||
/// The systems with their doctrines, and one system's doctrine (by id) (#47).
|
||||
@@ -246,6 +250,9 @@ const BTN_REPLAYS: u32 = 18;
|
||||
const BTN_RECON: u32 = 23;
|
||||
const REPLAY_EVENTS: u32 = 3;
|
||||
const RECON_ROWS: u32 = 6;
|
||||
const CHAIN_ROWS: u32 = 7;
|
||||
const BTN_CHAINS: u32 = 43;
|
||||
const BTN_CHAIN_FILTER: u32 = 44;
|
||||
const BTN_MAP: u32 = 40;
|
||||
const BTN_FULL: u32 = 41;
|
||||
const BTN_REEL: u32 = 42;
|
||||
@@ -1311,6 +1318,23 @@ impl AirDef {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Opens a battle chain's replay frame: its outcome clip when recorded, else the map at the
|
||||
/// launch (or the mark) held still.
|
||||
fn start_chain(&mut self, row: replay::ChainRow) -> Result<(), String> {
|
||||
match row.event {
|
||||
Some(i) => self.start_replay("clip", Some(i)),
|
||||
None => {
|
||||
self.start_replay("map", None)?;
|
||||
if let Some(player) = self.presentation.playback_mut()
|
||||
&& let Some(rec) = self.sim.replays.last()
|
||||
{
|
||||
player.seek(rec, row.at);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn stop_replay(&mut self) {
|
||||
let was_export = self.presentation.is_exporting();
|
||||
self.end_session(presentation::ExitCause::UserStop);
|
||||
@@ -1638,6 +1662,7 @@ impl AirDef {
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_MAP, label: "Карта налёта (R)".into() }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_FULL, label: "Полный повтор".into() }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_REEL, label: format!("Лучшие моменты ({})", replay::reel(rec).len()) }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_CHAINS, label: format!("Цепочки боя (разбор): {}", rec.chains(None).len()) }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_RECON, label: "Разведка противника (разбор)".into() }));
|
||||
}
|
||||
None => {
|
||||
@@ -1647,11 +1672,40 @@ impl AirDef {
|
||||
text: "Повторов пока нет: налёт записывается сам и появится здесь, когда небо очистится".into(),
|
||||
color: 0,
|
||||
}));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_CHAINS, label: "Цепочки боя (разбор)".into() }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_RECON, label: "Разведка противника (разбор)".into() }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
|
||||
}
|
||||
}
|
||||
}
|
||||
Page::Chains => {
|
||||
match self.sim.replays.last() {
|
||||
Some(rec) => {
|
||||
let rows = replay::chain_rows(rec, self.chain_filter);
|
||||
let filter = self.chain_filter.and_then(|id| {
|
||||
rec.sams.iter().position(|s| s.0 == id).map(|i| format!("№{} {}", i + 1, rec.sam(id).map_or("ПВО", |(k, _)| k.name())))
|
||||
});
|
||||
title = format!(
|
||||
"Цепочки боя: отметка → передача → захват → пуск → исход · {} · фильтр: {} · клик: кадр повтора",
|
||||
if rows.is_empty() { "нет цепочек".to_string() } else { format!("{}", rows.len()) },
|
||||
filter.unwrap_or_else(|| "все батареи".into()),
|
||||
);
|
||||
let rows = rows.into_iter().take(200).map(|r| r.text).collect();
|
||||
widgets.push(Widget::List(ListWidget { id: CHAIN_ROWS, rows, selected: None }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_CHAIN_FILTER, label: "Фильтр по батарее".into() }));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← К повторам".into() }));
|
||||
}
|
||||
None => {
|
||||
title = "Цепочки боя".into();
|
||||
widgets.push(Widget::Text(horizon_mod_sdk::ui::TextWidget {
|
||||
id: 0,
|
||||
text: "Повторов пока нет: цепочки появятся после первого налёта".into(),
|
||||
color: 0,
|
||||
}));
|
||||
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← К повторам".into() }));
|
||||
}
|
||||
}
|
||||
}
|
||||
Page::Recon => {
|
||||
title = "Разведка противника — разбор (debug): что враг запомнил и почему".into();
|
||||
let rows: Vec<String> = recon_view::picture_lines(&self.sim.enemy_picture()).into_iter().take(200).collect();
|
||||
@@ -1886,6 +1940,7 @@ impl Mod for AirDef {
|
||||
world: None,
|
||||
health_mark: 0,
|
||||
menu: None,
|
||||
chain_filter: None,
|
||||
listener: DVec3::ZERO,
|
||||
punch: 0.0,
|
||||
pending: Vec::new(),
|
||||
@@ -2321,6 +2376,37 @@ impl Mod for AirDef {
|
||||
self.open_menu(Page::Main);
|
||||
return;
|
||||
}
|
||||
(Page::Replays, BTN_CHAINS) => {
|
||||
self.open_menu(Page::Chains);
|
||||
return;
|
||||
}
|
||||
(Page::Chains, CHAIN_ROWS) => {
|
||||
let Some(rec) = self.sim.replays.last() else { return };
|
||||
let Some(row) = replay::chain_rows(rec, self.chain_filter).into_iter().nth(row as usize) else { return };
|
||||
match self.start_chain(row) {
|
||||
Ok(()) => {
|
||||
self.menu = None;
|
||||
ui::close_screen();
|
||||
}
|
||||
Err(e) => say(&e),
|
||||
}
|
||||
return;
|
||||
}
|
||||
(Page::Chains, BTN_CHAIN_FILTER) => {
|
||||
// All → each battery → all. Only systems are offered; a battery with no chains
|
||||
// still narrows the list to "nothing", which is the honest answer.
|
||||
let ids: Vec<u32> = self.sim.sams.iter().map(|s| s.id).collect();
|
||||
self.chain_filter = match self.chain_filter {
|
||||
None => ids.first().copied(),
|
||||
Some(id) => ids.iter().position(|x| *x == id).and_then(|i| ids.get(i + 1).copied()),
|
||||
};
|
||||
self.open_menu(Page::Chains);
|
||||
return;
|
||||
}
|
||||
(Page::Chains, BTN_BACK) => {
|
||||
self.open_menu(Page::Replays);
|
||||
return;
|
||||
}
|
||||
(Page::Main, BTN_RECON) | (Page::Replays, BTN_RECON) => {
|
||||
self.open_menu(Page::Recon);
|
||||
return;
|
||||
@@ -2492,11 +2578,53 @@ impl Mod for AirDef {
|
||||
if i >= self.sim.sams.len() {
|
||||
return Err("Нет такой техники".into());
|
||||
}
|
||||
// `/airdef why <n> source`: move the monitor to the station that measured the mark.
|
||||
if rest.get(1).is_some_and(|w| *w == "source") {
|
||||
let mark = self.sim.battle_reason(i).and_then(|r| r.mark);
|
||||
let Some(mark) = mark else { return Err("У комплекса нет отметки: источник неизвестен".into()) };
|
||||
if mark.own {
|
||||
return Err("Отметка своя: источник — сама батарея".into());
|
||||
}
|
||||
let Some(source) = mark.source else { return Err("Источник отметки неизвестен".into()) };
|
||||
self.monitor = Some(source);
|
||||
let name = self.sim.sams.get(source).map_or("РЛС", |s| s.kind.name());
|
||||
return Ok(Some(format!(
|
||||
"Переход к источнику отметки: №{} {}, возраст {:.1} с",
|
||||
source + 1,
|
||||
name,
|
||||
mark.age as f64 / 20.0
|
||||
)));
|
||||
}
|
||||
for c in self.sim.why(i) {
|
||||
say(&format!("{} {}", if c.ok { "+" } else { "-" }, why_view::reason(&c.reason)));
|
||||
}
|
||||
if let Some(mark) = self.sim.battle_reason(i).and_then(|r| r.mark)
|
||||
&& !mark.own
|
||||
&& mark.source.is_some()
|
||||
{
|
||||
say(&format!("Источник отметки: перейти — /airdef why {} source", i + 1));
|
||||
}
|
||||
None
|
||||
}
|
||||
["chains", rest @ ..] => {
|
||||
let battery = match rest.first() {
|
||||
Some(n) => {
|
||||
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("/airdef chains [номер батареи]")?;
|
||||
Some(self.sim.sams.get(i).ok_or("Нет такой техники")?.id)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let Some(rec) = self.sim.replays.last() else { return Err("Повторов пока нет: запишется первый же налёт".into()) };
|
||||
let rows = replay::chain_rows(rec, battery);
|
||||
if rows.is_empty() {
|
||||
say("Цепочек нет: в записи не было ни одной отметки (или формат старый)");
|
||||
} else {
|
||||
for row in rows.iter().take(200) {
|
||||
say(&row.text);
|
||||
}
|
||||
}
|
||||
Some("Клик по строке в меню N → «Повторы…» → «Цепочки боя» открывает кадр повтора".into())
|
||||
}
|
||||
["raid"] => {
|
||||
self.launch_wave(&mut out)?;
|
||||
None
|
||||
@@ -2760,6 +2888,7 @@ mod tests {
|
||||
world: None,
|
||||
health_mark: 0,
|
||||
menu: None,
|
||||
chain_filter: None,
|
||||
listener: DVec3::ZERO,
|
||||
punch: 0.0,
|
||||
pending: Vec::new(),
|
||||
|
||||
+107
-1
@@ -9,7 +9,7 @@ use crate::sim::catalog::sound;
|
||||
use crate::film::{self, Film};
|
||||
use crate::panel::distance;
|
||||
use crate::sim::Ground;
|
||||
use crate::sim::record::{EventKind, Recording, STEP, StrikeResult, What};
|
||||
use crate::sim::record::{Chain, ChainOutcome, ChainStepKind, EventKind, Recording, STEP, StrikeResult, What};
|
||||
use std::cell::Cell;
|
||||
use crate::sim::{Class, DroneKind, Out, Sim};
|
||||
use glam::DVec3;
|
||||
@@ -187,6 +187,67 @@ pub fn row(rec: &Recording, i: usize) -> String {
|
||||
format!("{} {what}", clock(e.at as f64))
|
||||
}
|
||||
|
||||
/// A row of the after-action chain list and where a click on it opens a replay.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct ChainRow {
|
||||
pub text: String,
|
||||
/// The recorded event to clip (the outcome), when there is one.
|
||||
pub event: Option<usize>,
|
||||
/// Otherwise the recording's tick to open the map at (the launch, else the mark).
|
||||
pub at: f64,
|
||||
}
|
||||
|
||||
/// The short chains of a raid: отметка → передача → захват → пуск → исход, filtered by a
|
||||
/// battery's id when asked. The list is the recording's measured transitions, not a guess.
|
||||
pub fn chain_rows(rec: &Recording, battery: Option<u32>) -> Vec<ChainRow> {
|
||||
rec.chains(battery).iter().map(|chain| ChainRow { text: chain_row(rec, chain), event: chain.outcome_event(), at: chain_jump_at(chain) }).collect()
|
||||
}
|
||||
|
||||
/// Where a chain opens in a replay when its outcome has no recorded event.
|
||||
fn chain_jump_at(chain: &Chain) -> f64 {
|
||||
chain
|
||||
.step(ChainStepKind::Launch)
|
||||
.or_else(|| chain.step(ChainStepKind::Mark))
|
||||
.map_or(0.0, |s| s.at as f64)
|
||||
}
|
||||
|
||||
fn chain_step_name(chain: &Chain, kind: ChainStepKind, own: bool) -> &'static str {
|
||||
match kind {
|
||||
ChainStepKind::Mark => "отметка",
|
||||
ChainStepKind::Handoff if own => "передача (своя РЛС)",
|
||||
ChainStepKind::Handoff => "передача (сеть)",
|
||||
ChainStepKind::Lock => "захват",
|
||||
ChainStepKind::Launch => "пуск",
|
||||
ChainStepKind::Outcome => match chain.outcome {
|
||||
ChainOutcome::Destroyed => "сбит",
|
||||
ChainOutcome::Hit => "прорыв",
|
||||
ChainOutcome::Lost => "потерян",
|
||||
ChainOutcome::Unfinished => "без исхода",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// One chain as a line: the battery, its contact, and the four or five measured steps.
|
||||
pub fn chain_row(rec: &Recording, chain: &Chain) -> String {
|
||||
let index = rec.sams.iter().position(|s| s.0 == chain.sam).map(|i| i + 1);
|
||||
let kind = rec.sam(chain.sam).map_or("ПВО", |(kind, _)| kind.name());
|
||||
let target = rec
|
||||
.track(chain.target)
|
||||
.and_then(|t| match t.what {
|
||||
What::Drone(kind) => Some(kind.spec().name),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap_or("цель");
|
||||
let steps: Vec<String> = chain.steps.iter().map(|s| format!("{} {}", chain_step_name(chain, s.kind, s.own), clock(s.at as f64))).collect();
|
||||
let battery = index.map_or_else(|| format!("№? {kind}"), |i| format!("№{i} {kind}"));
|
||||
format!(
|
||||
"{} {battery} → «{target}»: {}{}",
|
||||
clock(chain.marked_at() as f64),
|
||||
steps.join(" → "),
|
||||
if chain.missed() { " · без пуска" } else { "" },
|
||||
)
|
||||
}
|
||||
|
||||
/// How worth watching an event is: the reel takes the best.
|
||||
pub fn interest(rec: &Recording, i: usize) -> f64 {
|
||||
let e = &rec.events[i];
|
||||
@@ -299,6 +360,16 @@ impl Player {
|
||||
}
|
||||
}
|
||||
|
||||
/// Opens the replay at a recording tick (a chain's launch or mark), holding that frame.
|
||||
pub fn seek(&mut self, rec: &Recording, at: f64) {
|
||||
self.t = at.clamp(0.0, rec.len as f64);
|
||||
self.heard = self.t;
|
||||
self.shot = (usize::MAX, 0);
|
||||
self.fade = 0;
|
||||
self.card = 0;
|
||||
self.paused = true;
|
||||
}
|
||||
|
||||
/// The wheel: scrubs the map and the full replay, skips clips.
|
||||
pub fn wheel(&mut self, steps: f32, rec: &Recording) {
|
||||
let c = if steps > 0.0 { Control::Back } else { Control::Forward };
|
||||
@@ -1102,6 +1173,41 @@ impl Player {
|
||||
mod surface_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_chain_row_lists_the_measured_steps_and_opens_its_frame() {
|
||||
use crate::sim::record::{Event, SceneEvent, SceneJournal, SceneKind};
|
||||
use crate::sim::outcome::Outcome;
|
||||
use crate::sim::MissileKind;
|
||||
let mut rec = Recording::blank(300);
|
||||
rec.sams = vec![(10, crate::sim::SamKind::Pantsir, DVec3::ZERO)];
|
||||
rec.straight(7, What::Drone(DroneKind::Shahed), 0, 200, DVec3::new(0.0, 80.0, 0.0), DVec3::new(200.0, 80.0, 0.0));
|
||||
let mut scene = SceneJournal::default();
|
||||
let at = |at: u32, kind| SceneEvent { at, pos: DVec3::ZERO, kind };
|
||||
scene.fixture_push(at(20, SceneKind::TrackAcquired { sam: 10, target: 7, ever_own: false }));
|
||||
scene.fixture_push(at(30, SceneKind::TrackSource { sam: 10, target: 7, ever_own: true }));
|
||||
scene.fixture_push(at(40, SceneKind::TrackLock { sam: 10, target: 7, locked: true }));
|
||||
scene.fixture_push(at(50, SceneKind::MissileLaunch { missile: 500, sam: 10, target: 7, kind: MissileKind::M57e6, sound: "airdef:launch.pantsir", pitch: 1.0 }));
|
||||
rec.scene = Some(scene);
|
||||
rec.events.push(Event {
|
||||
at: 90,
|
||||
pos: DVec3::ZERO,
|
||||
kind: EventKind::Kill { drone: 7, kind: DroneKind::Shahed, sam: 10, sam_kind: crate::sim::SamKind::Pantsir, sam_index: 0, missile: Some(500), outcome: Outcome::DisabledFalling },
|
||||
});
|
||||
let rows = chain_rows(&rec, None);
|
||||
assert_eq!(rows.len(), 1);
|
||||
for step in ["отметка", "передача", "захват", "пуск", "сбит"] {
|
||||
assert!(rows[0].text.contains(step), "the chain row misses {step}: {}", rows[0].text);
|
||||
}
|
||||
assert_eq!(rows[0].event, Some(0));
|
||||
assert!(chain_rows(&rec, Some(10)).len() == 1);
|
||||
assert!(chain_rows(&rec, Some(11)).is_empty());
|
||||
// A chain with no recorded outcome opens its launch frame on the map, held still.
|
||||
let mut player = Player::new(1, Mode::Map, &Sim::new(1));
|
||||
player.seek(&rec, rows[0].at);
|
||||
assert!(player.paused);
|
||||
assert!((player.time() - rows[0].at).abs() < 1e-9);
|
||||
}
|
||||
|
||||
/// A gun standing on the sea floor films from above the water, not from under it.
|
||||
#[test]
|
||||
fn the_gun_camera_is_lifted_above_the_water() {
|
||||
|
||||
@@ -275,6 +275,77 @@ pub struct Event {
|
||||
pub kind: EventKind,
|
||||
}
|
||||
|
||||
/// One step of a short after-action chain: отметка → передача → захват → пуск → исход.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
pub enum ChainStepKind {
|
||||
/// The contact first appears on the battery's picture.
|
||||
Mark,
|
||||
/// The plot's source changes (a relay became the battery's own measurement, or the reverse).
|
||||
Handoff,
|
||||
/// The battery's own radar locks it.
|
||||
Lock,
|
||||
/// The battery launches an interceptor at it.
|
||||
Launch,
|
||||
/// What came of the chain: shot down, broke through, lost.
|
||||
Outcome,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
pub enum ChainOutcome {
|
||||
Destroyed,
|
||||
/// The target reached its aim (an object, a system, the land).
|
||||
Hit,
|
||||
Lost,
|
||||
/// The recording ended or the chain was cut short.
|
||||
Unfinished,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct ChainStep {
|
||||
pub kind: ChainStepKind,
|
||||
pub at: u32,
|
||||
/// The recorded event a replay can open (the outcome), when there is one.
|
||||
pub event: Option<usize>,
|
||||
/// For the mark and the handoff: the plot is the battery's own measurement.
|
||||
pub own: bool,
|
||||
/// For a launch: the interceptor's id.
|
||||
pub missile: Option<u32>,
|
||||
}
|
||||
|
||||
/// A battery's short engagement history for one contact, built from the recording's measured
|
||||
/// scene transitions and events. At most one step of each kind: no inferred beats.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Chain {
|
||||
pub sam: u32,
|
||||
pub target: u32,
|
||||
pub steps: Vec<ChainStep>,
|
||||
pub outcome: ChainOutcome,
|
||||
}
|
||||
|
||||
impl Chain {
|
||||
pub fn marked_at(&self) -> u32 {
|
||||
self.steps.first().map_or(0, |s| s.at)
|
||||
}
|
||||
|
||||
pub fn step(&self, kind: ChainStepKind) -> Option<&ChainStep> {
|
||||
self.steps.iter().find(|s| s.kind == kind)
|
||||
}
|
||||
|
||||
pub fn launched(&self) -> bool {
|
||||
self.step(ChainStepKind::Launch).is_some()
|
||||
}
|
||||
|
||||
/// A contact that appeared on the picture and was never launched at.
|
||||
pub fn missed(&self) -> bool {
|
||||
!self.launched()
|
||||
}
|
||||
|
||||
/// The event a replay clip opens on: the outcome when there is one, else nothing.
|
||||
pub fn outcome_event(&self) -> Option<usize> {
|
||||
self.step(ChainStepKind::Outcome).and_then(|s| s.event)
|
||||
}
|
||||
}
|
||||
|
||||
/// Measured scene transitions. These are facts, not inferred cinematic beats.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum SceneKind {
|
||||
@@ -867,6 +938,119 @@ impl Recording {
|
||||
pub fn sam(&self, id: u32) -> Option<(SamKind, DVec3)> {
|
||||
self.sams.iter().find(|s| s.0 == id).map(|s| (s.1, s.2))
|
||||
}
|
||||
|
||||
/// The battery's short chains through this raid, one per contact, in the order they began:
|
||||
/// the picture's own transitions (mark, handoff, lock, launch) and the recorded outcome.
|
||||
/// `battery` filters by system id; None keeps all. A recording with no scene journal (the
|
||||
/// legacy format) has no chains, and a truncated one may miss a later step — that is marked
|
||||
/// by `SceneJournal::truncated`, never guessed.
|
||||
pub fn chains(&self, battery: Option<u32>) -> Vec<Chain> {
|
||||
let Some(scene) = &self.scene else { return Vec::new() };
|
||||
let mut chains: std::collections::BTreeMap<(u32, u32), Chain> = std::collections::BTreeMap::new();
|
||||
for event in scene.events() {
|
||||
match event.kind {
|
||||
SceneKind::TrackAcquired { sam, target, ever_own } => {
|
||||
let chain = chains.entry((sam, target)).or_insert_with(|| Chain {
|
||||
sam,
|
||||
target,
|
||||
steps: Vec::new(),
|
||||
outcome: ChainOutcome::Unfinished,
|
||||
});
|
||||
if chain.steps.is_empty() {
|
||||
chain.steps.push(ChainStep { kind: ChainStepKind::Mark, at: event.at, event: None, own: ever_own, missile: None });
|
||||
}
|
||||
}
|
||||
SceneKind::TrackSource { sam, target, ever_own } => {
|
||||
if let Some(chain) = chains.get_mut(&(sam, target))
|
||||
&& chain.step(ChainStepKind::Handoff).is_none()
|
||||
{
|
||||
chain.steps.push(ChainStep { kind: ChainStepKind::Handoff, at: event.at, event: None, own: ever_own, missile: None });
|
||||
}
|
||||
}
|
||||
SceneKind::TrackLock { sam, target, locked: true } => {
|
||||
if let Some(chain) = chains.get_mut(&(sam, target))
|
||||
&& chain.step(ChainStepKind::Lock).is_none()
|
||||
{
|
||||
chain.steps.push(ChainStep { kind: ChainStepKind::Lock, at: event.at, event: None, own: true, missile: None });
|
||||
}
|
||||
}
|
||||
SceneKind::MissileLaunch { sam, target, missile, .. } => {
|
||||
if let Some(chain) = chains.get_mut(&(sam, target))
|
||||
&& chain.step(ChainStepKind::Launch).is_none()
|
||||
{
|
||||
chain.steps.push(ChainStep { kind: ChainStepKind::Launch, at: event.at, event: None, own: true, missile: Some(missile) });
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
// The outcomes are the recorded events; a kill identifies its chain by the battery and
|
||||
// the target, or by the interceptor when another battery's kill shares the target.
|
||||
for (index, event) in self.events.iter().enumerate() {
|
||||
match event.kind {
|
||||
EventKind::Kill { drone, sam, missile, .. } => {
|
||||
let mut keys = vec![(sam, drone)];
|
||||
if let Some(missile) = missile {
|
||||
keys.extend(chains.iter().filter(|(_, c)| c.steps.iter().any(|s| s.missile == Some(missile))).map(|(k, _)| *k));
|
||||
}
|
||||
for key in keys {
|
||||
if let Some(chain) = chains.get_mut(&key) {
|
||||
set_chain_outcome(chain, ChainOutcome::Destroyed, event.at, Some(index));
|
||||
}
|
||||
}
|
||||
}
|
||||
EventKind::Hit { drone, sam, .. } => {
|
||||
let by_sam = sam.and_then(|(_, i)| self.sams.get(i).map(|s| s.0));
|
||||
for ((_, target), chain) in chains.iter_mut() {
|
||||
if *target == drone && by_sam.is_none_or(|id| id == chain.sam) {
|
||||
set_chain_outcome(chain, ChainOutcome::Hit, event.at, Some(index));
|
||||
}
|
||||
}
|
||||
}
|
||||
EventKind::Crash { drone, .. } => {
|
||||
for ((_, target), chain) in chains.iter_mut() {
|
||||
if *target == drone && !chain.launched() {
|
||||
set_chain_outcome(chain, ChainOutcome::Lost, event.at, Some(index));
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
// A contact dropped without an outcome and never fired at was missed, not engaged.
|
||||
for event in scene.events() {
|
||||
if let SceneKind::TrackLost { sam, target } = event.kind
|
||||
&& let Some(chain) = chains.get_mut(&(sam, target))
|
||||
&& !chain.launched()
|
||||
{
|
||||
set_chain_outcome(chain, ChainOutcome::Lost, event.at, None);
|
||||
}
|
||||
}
|
||||
let mut out: Vec<Chain> = chains
|
||||
.into_values()
|
||||
.filter(|c| battery.is_none_or(|id| c.sam == id))
|
||||
.filter(|c| !c.steps.is_empty())
|
||||
.collect();
|
||||
out.sort_by_key(|c| (c.marked_at(), c.sam, c.target));
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// Sets a chain's outcome, keeping the strongest one seen (shot down beats a hit, a hit beats a
|
||||
/// lost or unfinished chain) and at most one outcome step.
|
||||
fn set_chain_outcome(chain: &mut Chain, outcome: ChainOutcome, at: u32, event: Option<usize>) {
|
||||
let rank = |o: ChainOutcome| match o {
|
||||
ChainOutcome::Destroyed => 3,
|
||||
ChainOutcome::Hit => 2,
|
||||
ChainOutcome::Lost => 1,
|
||||
ChainOutcome::Unfinished => 0,
|
||||
};
|
||||
if rank(chain.outcome) > rank(outcome) {
|
||||
return;
|
||||
}
|
||||
chain.outcome = outcome;
|
||||
chain.steps.retain(|s| s.kind != ChainStepKind::Outcome);
|
||||
chain.steps.push(ChainStep { kind: ChainStepKind::Outcome, at, event, own: false, missile: None });
|
||||
}
|
||||
|
||||
impl Sim {
|
||||
@@ -1153,6 +1337,49 @@ mod tests {
|
||||
s
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn battle_chains_keep_four_or_five_measured_steps_and_filter_by_battery() {
|
||||
let mut r = Recording::blank(400);
|
||||
r.sams = vec![(10, SamKind::Pantsir, DVec3::ZERO), (20, SamKind::S400, DVec3::new(200.0, 64.0, 0.0))];
|
||||
let mut scene = SceneJournal::default();
|
||||
let at = |at: u32, kind| SceneEvent { at, pos: DVec3::ZERO, kind };
|
||||
scene.push(at(20, SceneKind::TrackAcquired { sam: 10, target: 7, ever_own: false }));
|
||||
scene.push(at(30, SceneKind::TrackSource { sam: 10, target: 7, ever_own: true }));
|
||||
scene.push(at(40, SceneKind::TrackLock { sam: 10, target: 7, locked: true }));
|
||||
scene.push(at(50, SceneKind::MissileLaunch { missile: 500, sam: 10, target: 7, kind: MissileKind::M57e6, sound: "airdef:launch.pantsir", pitch: 1.0 }));
|
||||
scene.push(at(70, SceneKind::TrackLost { sam: 10, target: 7 }));
|
||||
r.scene = Some(scene);
|
||||
r.events.push(Event {
|
||||
at: 60,
|
||||
pos: DVec3::ZERO,
|
||||
kind: EventKind::Kill { drone: 7, kind: DroneKind::Shahed, sam: 10, sam_kind: SamKind::Pantsir, sam_index: 0, missile: Some(500), outcome: Outcome::DisabledFalling },
|
||||
});
|
||||
let chains = r.chains(None);
|
||||
assert_eq!(chains.len(), 1);
|
||||
let chain = &chains[0];
|
||||
let kinds: Vec<ChainStepKind> = chain.steps.iter().map(|s| s.kind).collect();
|
||||
assert_eq!(kinds, vec![ChainStepKind::Mark, ChainStepKind::Handoff, ChainStepKind::Lock, ChainStepKind::Launch, ChainStepKind::Outcome]);
|
||||
assert_eq!(chain.outcome, ChainOutcome::Destroyed);
|
||||
assert_eq!(chain.outcome_event(), Some(0));
|
||||
assert!(!chain.missed());
|
||||
assert_eq!(chain.marked_at(), 20);
|
||||
assert_eq!(r.chains(Some(10)).len(), 1);
|
||||
assert!(r.chains(Some(20)).is_empty(), "the filter picked another battery");
|
||||
|
||||
// A contact marked and lost without a launch is a missed chain, not an engagement.
|
||||
let mut r = Recording::blank(100);
|
||||
r.sams = vec![(10, SamKind::Pantsir, DVec3::ZERO)];
|
||||
let mut scene = SceneJournal::default();
|
||||
scene.push(at(10, SceneKind::TrackAcquired { sam: 10, target: 8, ever_own: false }));
|
||||
scene.push(at(50, SceneKind::TrackLost { sam: 10, target: 8 }));
|
||||
r.scene = Some(scene);
|
||||
let chain = &r.chains(None)[0];
|
||||
assert!(chain.missed());
|
||||
assert_eq!(chain.outcome, ChainOutcome::Lost);
|
||||
assert_eq!(chain.steps.len(), 2);
|
||||
assert_eq!(chain.outcome_event(), None);
|
||||
}
|
||||
|
||||
fn recording() -> Recording {
|
||||
Recording {
|
||||
number: 1,
|
||||
|
||||
@@ -287,6 +287,312 @@ pub enum CheckReason {
|
||||
Text(String),
|
||||
Parts(Vec<(Part, f64)>),
|
||||
PartEffect(PartEffect),
|
||||
/// The one headline reason a battery fires or does not, shared by the sim, the monitor and
|
||||
/// the chat command.
|
||||
Battle(BattleReason),
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- the one headline reason
|
||||
|
||||
/// What a battery's picture holds of a contact: the newest plot, its age and the station that
|
||||
/// made it. Only what the battery itself can know: a relayed plot's source, never the drone's
|
||||
/// true kind or place.
|
||||
#[derive(Clone, Copy, PartialEq, Debug)]
|
||||
pub struct BattleMark {
|
||||
/// Ticks since the newest measurement (any station).
|
||||
pub age: u64,
|
||||
/// Ticks since this battery's own radar measured it, if it ever did.
|
||||
pub own_age: Option<u64>,
|
||||
/// The station that made the newest plot, as an index into `Sim::sams`.
|
||||
pub source: Option<usize>,
|
||||
/// The newest plot is this battery's own measurement.
|
||||
pub own: bool,
|
||||
/// What the newest plot is good for.
|
||||
pub product: battery::Measure,
|
||||
pub quality: u8,
|
||||
/// This battery's own measurement's product, if it has one.
|
||||
pub own_product: Option<battery::Measure>,
|
||||
/// The plot is carried on as a forecast, not a fresh measurement.
|
||||
pub forecast: bool,
|
||||
/// The class the picture estimated, never the target's own kind.
|
||||
pub class: ClassEst,
|
||||
}
|
||||
|
||||
impl BattleMark {
|
||||
fn of(sim: &Sim, sam: &Sam, track: &sight::Track, now: u64) -> Self {
|
||||
BattleMark {
|
||||
age: track.age(now),
|
||||
own_age: (track.own_tick > 0).then(|| now.saturating_sub(track.own_tick)),
|
||||
source: sim.sams.iter().position(|s| s.id == track.source),
|
||||
own: track.source == sam.id,
|
||||
product: track.product,
|
||||
quality: track.quality,
|
||||
own_product: (track.own_tick > 0).then_some(track.own_product),
|
||||
forecast: track.forecast(now),
|
||||
class: track.class,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The headline state of a battery, in the words the player asks with.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
pub enum BattleKind {
|
||||
/// It can fire at the target it holds now.
|
||||
Ready,
|
||||
/// Есть только обзор: a search plot or a relayed one, no fire-quality measurement.
|
||||
ObserveOnly,
|
||||
/// Ждёт сопровождения: its own radar is refining, or a launcher waits for a supporting
|
||||
/// radar's fire plot.
|
||||
AwaitingTrack,
|
||||
/// Каналы заняты: every tracked-contact channel of its radar is in use by other contacts.
|
||||
ChannelsBusy,
|
||||
/// Нет боезапаса: no rounds and no shells, or reloading.
|
||||
NoAmmo,
|
||||
/// Something else stops it, named by `block`.
|
||||
Blocked,
|
||||
}
|
||||
|
||||
/// What stops a battery that is otherwise ready to engage.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
pub enum BattleBlock {
|
||||
Destroyed,
|
||||
Moving,
|
||||
Hold,
|
||||
NoWeapon,
|
||||
NoTarget,
|
||||
NoTrack,
|
||||
OutOfRoles,
|
||||
OutOfReach,
|
||||
Claimed,
|
||||
Doctrine,
|
||||
Aiming,
|
||||
Preparing,
|
||||
LauncherDown,
|
||||
Other,
|
||||
}
|
||||
|
||||
/// The one reason, in a typed form. `mark` is the contact's own picture (age, source, product);
|
||||
/// a hidden truth never enters it.
|
||||
#[derive(Clone, Copy, PartialEq, Debug)]
|
||||
pub struct BattleReason {
|
||||
pub kind: BattleKind,
|
||||
pub block: Option<BattleBlock>,
|
||||
pub sam: usize,
|
||||
pub target: Option<u32>,
|
||||
pub mark: Option<BattleMark>,
|
||||
pub rounds: u32,
|
||||
pub bursts: u32,
|
||||
/// Ticks left of a reload, 0 when loaded.
|
||||
pub reloading: u32,
|
||||
/// Tracked-contact channels in use and their total, when the radar has any.
|
||||
pub channels: Option<(usize, u8)>,
|
||||
}
|
||||
|
||||
impl BattleReason {
|
||||
pub fn ready(self) -> bool {
|
||||
self.kind == BattleKind::Ready
|
||||
}
|
||||
|
||||
/// The detailed decision (`why`) is the authority on whether a shot goes now: a headline
|
||||
/// that promised a shot it cannot take, or denied one it takes, is corrected here.
|
||||
pub fn settle(&mut self, fires: bool) {
|
||||
match (fires, self.kind == BattleKind::Ready) {
|
||||
(true, false) => {
|
||||
self.kind = BattleKind::Ready;
|
||||
self.block = None;
|
||||
}
|
||||
(false, true) => {
|
||||
self.kind = BattleKind::Blocked;
|
||||
self.block = Some(BattleBlock::Other);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Sim {
|
||||
/// Why battery `index` fires or doesn't, as one typed reason for the target it holds or the
|
||||
/// most threatening one its picture allows. The same predicates `step_sams` uses.
|
||||
pub fn battle_reason(&self, index: usize) -> Option<BattleReason> {
|
||||
self.battle_reason_at(index, None)
|
||||
}
|
||||
|
||||
/// The same, for a chosen contact (else the system's target, else the most threatening).
|
||||
pub fn battle_reason_at(&self, index: usize, chosen: Option<u32>) -> Option<BattleReason> {
|
||||
let sam = self.sams.get(index)?;
|
||||
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));
|
||||
let reason = |kind, block, target, mark| BattleReason {
|
||||
kind,
|
||||
block,
|
||||
sam: index,
|
||||
target,
|
||||
mark,
|
||||
rounds: sam.missiles,
|
||||
bursts: sam.bursts,
|
||||
reloading: sam.reloading,
|
||||
channels,
|
||||
};
|
||||
if !sam.alive() {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Destroyed), None, None));
|
||||
}
|
||||
if self.hold {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Hold), None, None));
|
||||
}
|
||||
if sam.moving() {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Moving), None, None));
|
||||
}
|
||||
if !sam.kind.armed() {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::NoWeapon), None, None));
|
||||
}
|
||||
let (missile_on, guns_on) = engagement_counts(&self.sams);
|
||||
let drone_at = |id: u32| self.drones.iter().find(|d| d.id == id);
|
||||
let subject = chosen
|
||||
.and_then(drone_at)
|
||||
.filter(|d| d.alive())
|
||||
.or_else(|| sam.target.or(sam.gun_target).and_then(drone_at).filter(|d| d.alive()))
|
||||
.or_else(|| {
|
||||
self.drones
|
||||
.iter()
|
||||
.filter(|d| {
|
||||
d.alive()
|
||||
&& (sam.track(d.id).is_some_and(|tr| tr.class.in_roles(sam.roles))
|
||||
|| last_chance(self.last_chance, sam.roles, sam.track(d.id).map_or(ClassEst::Unknown, |tr| tr.class), d, claimed(d, &missile_on, sam.target)))
|
||||
})
|
||||
.max_by(|a, b| {
|
||||
let area = |d: &Drone| sam.track(d.id).is_none_or(|tr| sam.doctrine.area_blocks(sam.pos, tr, now) == 0);
|
||||
area(a).cmp(&area(b)).then(a.threat(sam.pos).total_cmp(&b.threat(sam.pos)))
|
||||
})
|
||||
});
|
||||
let Some(t) = subject else {
|
||||
let block = if sam.roles == 0 {
|
||||
BattleBlock::Hold
|
||||
} else if self.drones.iter().any(|d| d.alive() && sam.seen.contains(&d.id)) {
|
||||
BattleBlock::OutOfRoles
|
||||
} else {
|
||||
BattleBlock::NoTarget
|
||||
};
|
||||
return Some(reason(BattleKind::Blocked, Some(block), None, None));
|
||||
};
|
||||
let track = sam.track(t.id);
|
||||
let mark = track.map(|tr| BattleMark::of(self, sam, tr, now));
|
||||
let has_missile = spec.missile.is_some() && sam.missiles > 0 && sam.part(Part::Launcher) > 0.0;
|
||||
let has_gun = spec.gun.is_some() && sam.bursts > 0 && sam.part(Part::Gun) > 0.0;
|
||||
if sam.reloading > 0 || (!has_missile && !has_gun) {
|
||||
return Some(reason(BattleKind::NoAmmo, None, Some(t.id), mark));
|
||||
}
|
||||
if spec.missile.is_some() && sam.part(Part::Launcher) <= 0.0 && !has_gun {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::LauncherDown), Some(t.id), mark));
|
||||
}
|
||||
let Some(tr) = track else {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::NoTrack), Some(t.id), mark));
|
||||
};
|
||||
let est = tr.class;
|
||||
let blocks = target_blocks(sam.roles, Some(tr), now, t);
|
||||
let claimed_now = claimed(t, &missile_on, sam.target);
|
||||
let chance = blocks & ROLE != 0 && last_chance(self.last_chance, sam.roles, est, t, claimed_now);
|
||||
if blocks & ROLE != 0 && !chance {
|
||||
return Some(reason(BattleKind::Blocked, Some(if sam.roles == 0 { BattleBlock::Hold } else { BattleBlock::OutOfRoles }), Some(t.id), mark));
|
||||
}
|
||||
let doc = &sam.doctrine;
|
||||
let area = doc.area_blocks(sam.pos, tr, now);
|
||||
let reserve = spec.missile.is_some().then(|| doc.reserve_blocks(sam.missiles, t, est)).unwrap_or(0);
|
||||
if blocks & ROLE == 0 && (area | reserve) != 0 {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Doctrine), Some(t.id), mark));
|
||||
}
|
||||
let est_at = tr.est(now);
|
||||
let radars: Vec<&Sam> = self.sams.iter().filter(|s| s.kind == SamKind::Radar).collect();
|
||||
let cued = radar_cue(sam, &radars, t.id, now);
|
||||
let role_in_reach = spec.missile.as_ref().is_some_and(|load| {
|
||||
self.drones.iter().any(|o| {
|
||||
sam.track(o.id).is_some_and(|other| {
|
||||
allowed(sam.roles, other, now, o)
|
||||
&& in_reach(load.min, load.max, 1.0, sam.pos, other.est(now))
|
||||
&& doc.area_blocks(sam.pos, other, now) | doc.reserve_blocks(sam.missiles, o, other.class) == 0
|
||||
&& claimed(o, &missile_on, sam.target) < doc.needed(o, other.class)
|
||||
})
|
||||
})
|
||||
});
|
||||
let reach = spec.missile.as_ref().map_or(0, |load| reach_blocks(load.min, load.max, 1.0, sam.pos, est_at));
|
||||
let far_ok = spec.missile.as_ref().is_some_and(|load| {
|
||||
reach == TOO_FAR
|
||||
&& reach_blocks(load.min, load.max, FAR_K, sam.pos, est_at) == 0
|
||||
&& far_blocks(self.far_shots, sam, load, cued, role_in_reach) == 0
|
||||
});
|
||||
if spec.missile.is_some() {
|
||||
if reach == TOO_CLOSE || (reach == TOO_FAR && !far_ok) {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::OutOfReach), Some(t.id), mark));
|
||||
}
|
||||
} else if let Some(gun) = &spec.gun {
|
||||
if sam.mount().0.distance(est_at) >= gun.range {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::OutOfReach), Some(t.id), mark));
|
||||
}
|
||||
}
|
||||
let own_fire = tr.own_authorizes(now);
|
||||
let gun_ready = spec.gun.is_some() && tr.own_within(now, sight::GUN_PICK_AGE);
|
||||
let authorized = if spec.missile.is_some() {
|
||||
own_fire || (sam.mode == battery::SamMode::LauncherOnly && cued) || far_ok
|
||||
} else {
|
||||
gun_ready
|
||||
};
|
||||
if !authorized {
|
||||
if sam.mode == battery::SamMode::LauncherOnly {
|
||||
// The launcher's picture is the supporting radar's. If that radar has the
|
||||
// contact but every tracked-contact channel is taken, the reason is the
|
||||
// channels, not a missing hand-off.
|
||||
let support = radars.iter().find_map(|r| {
|
||||
let linked = r.alive()
|
||||
&& !r.moving()
|
||||
&& r.radar_up()
|
||||
&& r.radar_profile().products & battery::RadarProfile::FIRE_BIT != 0
|
||||
&& r.link_range() > 0.0
|
||||
&& sam.link_range() > 0.0
|
||||
&& r.pos.distance(sam.pos) <= r.link_range().min(sam.link_range());
|
||||
linked.then(|| r.track(t.id).map(|tr| (*r, *tr))).flatten()
|
||||
});
|
||||
if let Some((radar, tr)) = support {
|
||||
let profile = radar.radar_profile();
|
||||
let used = radar.own_channels_used();
|
||||
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));
|
||||
return Some(busy);
|
||||
}
|
||||
}
|
||||
return Some(reason(BattleKind::AwaitingTrack, None, Some(t.id), mark));
|
||||
}
|
||||
let busy = channels.is_some_and(|(used, total)| used >= total as usize);
|
||||
if busy {
|
||||
return Some(reason(BattleKind::ChannelsBusy, None, Some(t.id), mark));
|
||||
}
|
||||
if tr.own_tick > 0 && tr.own_product == battery::Measure::Refine {
|
||||
return Some(reason(BattleKind::AwaitingTrack, None, Some(t.id), mark));
|
||||
}
|
||||
if tr.own_tick > 0 && tr.own_product == battery::Measure::Fire {
|
||||
return Some(reason(BattleKind::AwaitingTrack, None, Some(t.id), mark));
|
||||
}
|
||||
return Some(reason(BattleKind::ObserveOnly, None, Some(t.id), mark));
|
||||
}
|
||||
let need = doc.needed(t, est);
|
||||
if spec.missile.is_some() && claimed_now >= need {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Claimed), Some(t.id), mark));
|
||||
}
|
||||
if spec.missile.is_none() && guns_on.get(&t.id).copied().unwrap_or(0) > 1 {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Claimed), Some(t.id), mark));
|
||||
}
|
||||
let mount = sam.mount().0;
|
||||
let lead_speed = spec.gun.as_ref().map_or(5.0, |g| g.shell);
|
||||
let (_, want_yaw, want_pitch) = aim_wants(mount, est_at, tr.vel, lead_speed);
|
||||
if aim_error(spec.family, sam.yaw, sam.pitch, want_yaw, want_pitch) >= 0.15 {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Aiming), Some(t.id), mark));
|
||||
}
|
||||
if sam.preparing.is_some() {
|
||||
return Some(reason(BattleKind::Blocked, Some(BattleBlock::Preparing), Some(t.id), mark));
|
||||
}
|
||||
Some(reason(BattleKind::Ready, None, Some(t.id), mark))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
@@ -310,6 +616,20 @@ fn check(ok: bool, text: impl Into<String>) -> Check {
|
||||
Check { ok, reason: CheckReason::Text(text.into()) }
|
||||
}
|
||||
fn part_check(reason: CheckReason) -> Check { Check { ok: false, reason } }
|
||||
fn battle_check(reason: Option<BattleReason>) -> Check {
|
||||
let reason = reason.unwrap_or(BattleReason {
|
||||
kind: BattleKind::Blocked,
|
||||
block: Some(BattleBlock::Other),
|
||||
sam: 0,
|
||||
target: None,
|
||||
mark: None,
|
||||
rounds: 0,
|
||||
bursts: 0,
|
||||
reloading: 0,
|
||||
channels: None,
|
||||
});
|
||||
Check { ok: reason.ready(), reason: CheckReason::Battle(reason) }
|
||||
}
|
||||
|
||||
impl Sim {
|
||||
/// Why system `index` fires or doesn't, at its current target or at the most threatening
|
||||
@@ -321,14 +641,17 @@ impl Sim {
|
||||
let mut v = vec![check(true, format!("№{} {}: {}", index + 1, spec.name, sam.state.name()))];
|
||||
if !sam.alive() {
|
||||
v.push(check(false, "уничтожен"));
|
||||
v.push(battle_check(self.battle_reason(index)));
|
||||
return v;
|
||||
}
|
||||
if self.hold {
|
||||
v.push(check(false, "огонь запрещён (/airdef hold off)"));
|
||||
v.push(battle_check(self.battle_reason(index)));
|
||||
return v;
|
||||
}
|
||||
if sam.moving() {
|
||||
v.push(check(false, format!("{}: не стреляет", sam.state.name().to_lowercase())));
|
||||
v.push(battle_check(self.battle_reason(index)));
|
||||
return v;
|
||||
}
|
||||
if !sam.kind.armed() {
|
||||
@@ -364,6 +687,7 @@ impl Sim {
|
||||
}
|
||||
}
|
||||
v.push(check(false, "нет оружия (РЛС, склад, РЭБ, прожектор)"));
|
||||
v.push(battle_check(self.battle_reason(index)));
|
||||
return v;
|
||||
}
|
||||
let logistics = self.logistics();
|
||||
@@ -430,6 +754,7 @@ impl Sim {
|
||||
format!("нет целей классов [{}]", roles_text(sam.roles))
|
||||
};
|
||||
v.push(check(false, text));
|
||||
v.push(battle_check(self.battle_reason(index)));
|
||||
return v;
|
||||
};
|
||||
let held = sam.target == Some(t.id) || sam.gun_target == Some(t.id);
|
||||
@@ -644,6 +969,21 @@ impl Sim {
|
||||
fires &= !opening;
|
||||
}
|
||||
v.push(check(fires, if fires { "итог: готова стрелять" } else { "итог: стрелять сейчас не может" }));
|
||||
// The one typed reason the monitor, the HUD and the chat show first; the detailed checks
|
||||
// below it explain it. The launch decision above has the final word.
|
||||
let mut headline = self.battle_reason_at(index, Some(t.id)).unwrap_or_else(|| BattleReason {
|
||||
kind: BattleKind::Blocked,
|
||||
block: Some(BattleBlock::Other),
|
||||
sam: index,
|
||||
target: Some(t.id),
|
||||
mark: track.map(|tr| BattleMark::of(self, sam, tr, now)),
|
||||
rounds: sam.missiles,
|
||||
bursts: sam.bursts,
|
||||
reloading: sam.reloading,
|
||||
channels: None,
|
||||
});
|
||||
headline.settle(fires);
|
||||
v.insert(1, Check { ok: headline.ready(), reason: CheckReason::Battle(headline) });
|
||||
v
|
||||
}
|
||||
}
|
||||
@@ -1016,6 +1356,129 @@ mod tests {
|
||||
assert!((reach_fit(100.0, 400.0) - 0.5).abs() < 1e-9);
|
||||
}
|
||||
|
||||
/// A track as the battery's picture holds it, from `source`, measured by the battery's own
|
||||
/// radar `own` ticks ago.
|
||||
fn seeded_track(id: u32, source: u32, own_tick: u64, product: battery::Measure, now: u64) -> Track {
|
||||
Track {
|
||||
id,
|
||||
class: ClassEst::Firm(Class::Drone),
|
||||
pos: DVec3::new(0.0, 75.0, -100.0),
|
||||
vel: DVec3::Z,
|
||||
tick: now,
|
||||
own_tick,
|
||||
source,
|
||||
product,
|
||||
quality: 90,
|
||||
own_product: product,
|
||||
own_quality: if own_tick > 0 { 90 } else { 0 },
|
||||
ttl: 400,
|
||||
hits: 3,
|
||||
locked: false,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_headline_reason_names_observation_waiting_channels_and_ammo() {
|
||||
// Есть только обзор: the contact is on the network's picture, the battery's own radar
|
||||
// has no fire plot, and no channel of its own is taken.
|
||||
let mut sim = Sim::new(7);
|
||||
let id = sim.id();
|
||||
sim.sams.push(Sam::new(id, SamKind::Pantsir, DVec3::new(0.0, 70.0, 0.0), 0.0));
|
||||
let radar = sim.id();
|
||||
sim.sams.push(Sam::new(radar, SamKind::Radar, DVec3::new(50.0, 70.0, 0.0), 0.0));
|
||||
sim.add_drone(DroneKind::Shahed, DVec3::new(0.0, 75.0, -100.0), DVec3::Z, DVec3::new(0.0, 70.0, -100.0));
|
||||
let target = sim.drones[0].id;
|
||||
let now = sim.tick;
|
||||
sim.sams[0].tracks.push(seeded_track(target, radar, 0, battery::Measure::Search, now));
|
||||
let reason = sim.battle_reason(0).expect("a reason");
|
||||
assert_eq!(reason.kind, BattleKind::ObserveOnly, "{reason:?}");
|
||||
let mark = reason.mark.expect("the mark");
|
||||
assert_eq!(mark.source, Some(1));
|
||||
assert!(!mark.own);
|
||||
assert_eq!(mark.age, 0);
|
||||
|
||||
// Ждёт сопровождения: a launcher without its own radar waits for the supporting radar's
|
||||
// fire plot; the same network mark is not enough.
|
||||
let mut sim = Sim::new(8);
|
||||
let id = sim.id();
|
||||
let mut launcher = Sam::new(id, SamKind::S400, DVec3::new(0.0, 70.0, 0.0), 0.0);
|
||||
launcher.set_mode(battery::SamMode::LauncherOnly);
|
||||
sim.sams.push(launcher);
|
||||
let radar = sim.id();
|
||||
let mut station = Sam::new(radar, SamKind::Radar, DVec3::new(10.0, 70.0, 0.0), 0.0);
|
||||
station.set_radar_role(battery::RadarRole::Engagement);
|
||||
sim.sams.push(station);
|
||||
sim.add_drone(DroneKind::Kh101, DVec3::new(0.0, 300.0, -300.0), DVec3::Z, DVec3::new(0.0, 70.0, 0.0));
|
||||
let target = sim.drones[0].id;
|
||||
let now = 1;
|
||||
sim.sams[0].tracks.push(seeded_track(target, radar, 0, battery::Measure::Search, now));
|
||||
assert_eq!(sim.battle_reason(0).expect("a reason").kind, BattleKind::AwaitingTrack);
|
||||
|
||||
// Каналы заняты: the supporting radar has the contact but both tracked-contact channels
|
||||
// are held by other contacts.
|
||||
sim.sams[1].tracks.push(seeded_track(901, radar, now, battery::Measure::Fire, now));
|
||||
sim.sams[1].tracks.push(seeded_track(902, radar, now, battery::Measure::Fire, now));
|
||||
sim.sams[1].tracks.push(seeded_track(target, radar, now, battery::Measure::Search, now));
|
||||
let reason = sim.battle_reason(0).expect("a reason");
|
||||
assert_eq!(reason.kind, BattleKind::ChannelsBusy, "{reason:?}");
|
||||
assert_eq!(reason.channels, Some((2, 2)));
|
||||
|
||||
// Нет боезапаса: no rounds and no shells.
|
||||
let mut sim = Sim::new(9);
|
||||
let id = sim.id();
|
||||
let mut sam = Sam::new(id, SamKind::Pantsir, DVec3::new(0.0, 70.0, 0.0), 0.0);
|
||||
sam.missiles = 0;
|
||||
sam.bursts = 0;
|
||||
sim.sams.push(sam);
|
||||
sim.add_drone(DroneKind::Shahed, DVec3::new(0.0, 75.0, -100.0), DVec3::Z, DVec3::new(0.0, 70.0, -100.0));
|
||||
let target = sim.drones[0].id;
|
||||
let now = sim.tick;
|
||||
sim.sams[0].tracks.push(seeded_track(target, id, now, battery::Measure::Fire, now));
|
||||
let reason = sim.battle_reason(0).expect("a reason");
|
||||
assert_eq!(reason.kind, BattleKind::NoAmmo, "{reason:?}");
|
||||
assert_eq!((reason.rounds, reason.bursts), (0, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_headline_reason_can_say_ready_and_defers_to_the_launch_decision() {
|
||||
let mut sim = Sim::new(11);
|
||||
let id = sim.id();
|
||||
sim.sams.push(Sam::new(id, SamKind::S400, DVec3::new(0.0, 70.0, 0.0), 0.0));
|
||||
sim.sams[0].cooldown = 0;
|
||||
sim.add_drone(DroneKind::Kh101, DVec3::new(0.0, 300.0, -300.0), DVec3::Z, DVec3::new(0.0, 70.0, 0.0));
|
||||
let d = sim.drones[0].clone();
|
||||
let now = 1;
|
||||
sim.sams[0].yaw = heading_of(d.pos - sim.sams[0].pos);
|
||||
sim.sams[0].tracks.push(Track {
|
||||
id: d.id,
|
||||
class: ClassEst::Firm(Class::Cruise),
|
||||
pos: d.pos,
|
||||
vel: d.vel,
|
||||
tick: now,
|
||||
own_tick: now,
|
||||
source: id,
|
||||
product: battery::Measure::Fire,
|
||||
quality: 90,
|
||||
own_product: battery::Measure::Fire,
|
||||
own_quality: 90,
|
||||
ttl: 400,
|
||||
hits: 3,
|
||||
locked: false,
|
||||
});
|
||||
let reason = sim.battle_reason(0).expect("a reason");
|
||||
assert_eq!(reason.kind, BattleKind::Ready, "{reason:?}");
|
||||
// The detailed decision is the authority when the two are settled together.
|
||||
let mut blocked = reason;
|
||||
blocked.settle(false);
|
||||
assert_eq!(blocked.kind, BattleKind::Blocked);
|
||||
let mut ready = reason;
|
||||
ready.settle(true);
|
||||
assert_eq!(ready.kind, BattleKind::Ready);
|
||||
// In the diagnostic the typed line is the headline, second only to the state.
|
||||
let checks = sim.why(0);
|
||||
assert!(matches!(checks.get(1).map(|c| &c.reason), Some(CheckReason::Battle(r)) if r.kind == BattleKind::Ready), "{checks:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_interceptor_lives_long_enough_to_fly_its_reach() {
|
||||
// Life × top speed must cover the far end of a heavy system's reach with room to chase; the rest their plain reach.
|
||||
|
||||
+107
-1
@@ -1,5 +1,5 @@
|
||||
//! Text for diagnostics produced by the simulation.
|
||||
use crate::sim::why::{CheckReason, PartEffect};
|
||||
use crate::sim::why::{BattleBlock, BattleKind, BattleMark, BattleReason, CheckReason, PartEffect};
|
||||
use crate::sim::{Comps, Part, SamKind};
|
||||
|
||||
fn part_value(part: Part, value: f64) -> String {
|
||||
@@ -25,9 +25,81 @@ pub fn worst(comps: &Comps, kind: SamKind) -> String {
|
||||
.map(|p| part_value_on(*p, comps.get(*p), kind)).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// The mark's age and where it came from, in the battery's own picture: a relayed plot names
|
||||
/// its station, never the target's true place or kind.
|
||||
fn mark_text(mark: &BattleMark) -> String {
|
||||
let age = if mark.age == 0 { "сейчас".to_string() } else { format!("{:.1} с назад", mark.age as f64 / 20.0) };
|
||||
let source = if mark.own {
|
||||
"своя РЛС".to_string()
|
||||
} else {
|
||||
mark.source.map_or_else(|| "сеть".to_string(), |i| format!("сеть, РЛС №{}", i + 1))
|
||||
};
|
||||
let mut own = String::new();
|
||||
if let Some(product) = mark.own_product {
|
||||
if !mark.own {
|
||||
own = format!(", своё измерение: {}", product.name());
|
||||
}
|
||||
}
|
||||
let forecast = if mark.forecast { ", прогноз" } else { "" };
|
||||
format!(
|
||||
"отметка {age}, источник {source}, {} кач.{} {}{}{forecast}",
|
||||
mark.product.name(),
|
||||
mark.quality,
|
||||
mark.class.name(),
|
||||
own
|
||||
)
|
||||
}
|
||||
|
||||
fn with_mark(text: String, mark: Option<BattleMark>) -> String {
|
||||
match mark {
|
||||
Some(mark) => format!("{text}: {}", mark_text(&mark)),
|
||||
None => text,
|
||||
}
|
||||
}
|
||||
|
||||
/// The one headline reason a battery fires or not, as the player reads it.
|
||||
pub fn battle_text(reason: &BattleReason) -> String {
|
||||
match reason.kind {
|
||||
BattleKind::Ready => with_mark("готов к пуску".into(), reason.mark),
|
||||
BattleKind::ObserveOnly => with_mark("есть только обзор, пуск не разрешён — нужно своё подтверждённое измерение".into(), reason.mark),
|
||||
BattleKind::AwaitingTrack => with_mark("ждёт сопровождения — своё измерение ещё не разрешает пуск".into(), reason.mark),
|
||||
BattleKind::ChannelsBusy => {
|
||||
let channels = reason.channels.map_or_else(|| "каналы заняты".to_string(), |(used, total)| format!("каналы заняты: {used}/{total}"));
|
||||
with_mark(channels, reason.mark)
|
||||
}
|
||||
BattleKind::NoAmmo => {
|
||||
let mut text = format!("нет боезапаса: ракет {}, очередей {}", reason.rounds, reason.bursts);
|
||||
if reason.reloading > 0 {
|
||||
text += &format!(", перезарядка ещё {:.1} с", reason.reloading as f64 / 20.0);
|
||||
}
|
||||
with_mark(text, reason.mark)
|
||||
}
|
||||
BattleKind::Blocked => {
|
||||
let text = match reason.block {
|
||||
Some(BattleBlock::Destroyed) => "уничтожен".to_string(),
|
||||
Some(BattleBlock::Moving) => "на марше, не стреляет".to_string(),
|
||||
Some(BattleBlock::Hold) => "огонь запрещён или роли не заданы".to_string(),
|
||||
Some(BattleBlock::NoWeapon) => "нет оружия (РЛС, склад, РЭБ, прожектор)".to_string(),
|
||||
Some(BattleBlock::NoTarget) => "нет целей в небе".to_string(),
|
||||
Some(BattleBlock::NoTrack) => "цель не обнаружена своей РЛС или сетью".to_string(),
|
||||
Some(BattleBlock::OutOfRoles) => "цель вне ролей комплекса".to_string(),
|
||||
Some(BattleBlock::OutOfReach) => "цель вне дальности".to_string(),
|
||||
Some(BattleBlock::Claimed) => "цель уже занята перехватчиками".to_string(),
|
||||
Some(BattleBlock::Doctrine) => "запрещено доктриной (сектор, охрана или резерв)".to_string(),
|
||||
Some(BattleBlock::Aiming) => "ещё доворачивается на цель".to_string(),
|
||||
Some(BattleBlock::Preparing) => "открывает ТПК".to_string(),
|
||||
Some(BattleBlock::LauncherDown) => "пусковая отказала".to_string(),
|
||||
Some(BattleBlock::Other) | None => "стрелять сейчас не может".to_string(),
|
||||
};
|
||||
with_mark(text, reason.mark)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn reason(reason: &CheckReason) -> String {
|
||||
match reason {
|
||||
CheckReason::Text(text) => text.clone(),
|
||||
CheckReason::Battle(battle) => battle_text(battle),
|
||||
CheckReason::Parts(parts) => format!("узлы: {}", parts.iter().map(|(part, value)| part_value(*part, *value)).collect::<Vec<_>>().join(", ")),
|
||||
CheckReason::PartEffect(effect) => match effect {
|
||||
PartEffect::SensorFailed => "РЛС отказала: своих измерений нет, стволы не стреляют, ракеты — по данным сети".into(),
|
||||
@@ -79,6 +151,40 @@ mod tests {
|
||||
assert!(summary < sensor && sensor < tracks, "{lines:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_headline_reason_shows_the_marks_age_and_source_without_the_true_kind() {
|
||||
use crate::sim::battery::Measure;
|
||||
use crate::sim::ClassEst;
|
||||
let mark = BattleMark {
|
||||
age: 46,
|
||||
own_age: None,
|
||||
source: Some(2),
|
||||
own: false,
|
||||
product: Measure::Search,
|
||||
quality: 40,
|
||||
own_product: None,
|
||||
forecast: false,
|
||||
class: ClassEst::Unknown,
|
||||
};
|
||||
let reason = BattleReason {
|
||||
kind: BattleKind::ObserveOnly,
|
||||
block: None,
|
||||
sam: 0,
|
||||
target: Some(7),
|
||||
mark: Some(mark),
|
||||
rounds: 4,
|
||||
bursts: 0,
|
||||
reloading: 0,
|
||||
channels: None,
|
||||
};
|
||||
let text = battle_text(&reason);
|
||||
assert!(text.starts_with("есть только обзор"), "{text}");
|
||||
assert!(text.contains("2.3 с назад"), "{text}");
|
||||
assert!(text.contains("источник сеть, РЛС №3"), "{text}");
|
||||
assert!(text.contains("тип не определён"), "{text}");
|
||||
assert!(!text.contains("Шахед"), "the true kind leaked into the HUD: {text}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn renders_damage_diagnostics() {
|
||||
assert_eq!(reason(&CheckReason::Parts(vec![(Part::Sensor, 0.4), (Part::Tracks, 0.0)])), "узлы: РЛС 40%, Ход отказ");
|
||||
|
||||
Reference in New Issue
Block a user