Move battery status text to the presentation adapter

Sam::status, Comps::describe/worst and Sam::parts_text formatted
player-facing Russian in the simulation. The adapter now owns that
text: battery_view::sam_status for the panel and map, why_view::parts
and why_view::worst for the monitor and the status line. The core keeps
the data and gains only the accessors the adapter needs
(preparing_cell, public cells/reload_time/magazine/gun facts).

Texts are unchanged; the adapter tests pin the existing strings.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
2026-11-20 18:17:46 +03:00
parent 60f1bf0fd8
commit 306af49744
8 changed files with 172 additions and 91 deletions
+124 -2
View File
@@ -1,5 +1,6 @@
//! Player-facing labels for battery configuration snapshots.
//! Player-facing labels for battery configuration and status.
use crate::sim::battery::{BatteryStatus, RadarRole, SamMode};
use crate::sim::{Sam, SamKind};
pub fn radar_role_name(role: RadarRole) -> &'static str {
match role {
@@ -26,10 +27,131 @@ 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 {
let spec = sam.kind.spec();
let mut text = spec.name.to_string();
if !sam.alive() {
return text + " УНИЧТОЖЕН";
}
if sam.moving() {
return text + " " + &sam.state.name().to_lowercase();
}
match sam.kind {
SamKind::Depot => return format!("{text}: {} перезарядок, RM48U {}, снятых ПВО {}", sam.cargo, sam.ground_stock, sam.air_48n6_stock),
SamKind::Tzm => return format!(
"{text}: на борту {}/2, RM48U {}, снятых ПВО {}{}",
sam.cargo,
sam.ground_stock,
sam.air_48n6_stock,
if sam.return_cargo { ", везёт RM48U на склад" } else if sam.job().is_some() { ", в пути" } else { "" }
),
SamKind::Ew => {
let state = if sam.ew_on { "ГЛУШИТ" } else if sam.ew_lock { "остывает" } else { "готова" };
return format!("{text}: {state}, нагрев {:.0}%", sam.heat * 100.0);
}
SamKind::Radar => {
let broken = if sam.comps.whole() { String::new() } else { format!(" [{}]", crate::why_view::worst(&sam.comps, sam.kind)) };
return format!("{text}: целей {}{broken}", sam.own.len());
}
SamKind::Light => return format!("{text}{}", if sam.target.is_some() { ": в луче цель" } else { "" }),
_ => {}
}
if let Some(cell) = sam.preparing_cell() {
text += &format!(" · открытие ТПК №{}", cell + 1);
}
if sam.empty && sam.missiles == 0 {
text += " ЖДЁТ БК";
}
if sam.health < 1.0 {
text += &format!(" ({:.0}%)", sam.health * 100.0);
}
if !sam.comps.whole() {
text += &format!(" [{}]", crate::why_view::worst(&sam.comps, sam.kind));
}
if sam.reloading > 0 {
text += &format!(" перезарядка {}с", sam.reloading.div_ceil(20));
} else {
if let Some(magazine) = sam.kind.missile_magazine() {
if sam.kind == SamKind::S400 {
text += &format!(" ПВО {} · RM48U {} / {} ячеек", sam.missiles, sam.ground_rounds, sam.cells());
if sam.ground_return { text += " · ожидает вывоза RM48U"; }
} else {
text += &format!(" ракеты {}/{}", sam.missiles, magazine);
}
}
if sam.kind.has_gun() {
text += &format!(" очереди {}", sam.bursts);
}
}
text
}
#[cfg(test)]
mod tests {
use super::*;
use crate::sim::SamKind;
use crate::sim::{Part, Sam, SamKind, SamState};
use glam::DVec3;
#[test]
fn renders_system_status_in_existing_format() {
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 ячеек");
s400.ground_return = true;
assert_eq!(sam_status(&s400), "С-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");
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с");
}
#[test]
fn renders_special_system_lines_in_existing_format() {
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 [РЛС отказ]");
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");
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 на склад");
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%");
let mut light = Sam::new(8, SamKind::Light, DVec3::ZERO, 0.0);
light.target = Some(1);
assert_eq!(sam_status(&light), "Прожектор: в луче цель");
}
#[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 на марше");
let mut dead = Sam::new(10, SamKind::S400, DVec3::ZERO, 0.0);
dead.health = 0.0;
assert_eq!(sam_status(&dead), "С-400 УНИЧТОЖЕН");
}
#[test]
fn renders_battery_status_in_existing_format() {
+1 -1
View File
@@ -2338,7 +2338,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((sam.status(), WHITE));
lines.push((crate::battery_view::sam_status(sam), WHITE));
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));
+1 -1
View File
@@ -209,7 +209,7 @@ fn cell(sim: &Sim, index: usize, x: f32, y: f32, w: f32, h: f32, s: &mut Vec<Sha
// Worn or failed parts, over the picture: orange, red when one has failed.
if !sam.comps.whole() {
let failed = crate::sim::Part::ALL.iter().any(|p| sam.part_state(*p) == crate::sim::PartState::Failed);
s.push(text(fit(sam.parts_text(), cw * 0.55), cx + 3.0, cy + 3.0, if failed { 0xFFFF4040 } else { 0xFFFFB030 }));
s.push(text(fit(crate::why_view::parts(&sam.comps, sam.kind), cw * 0.55), cx + 3.0, cy + 3.0, if failed { 0xFFFF4040 } else { 0xFFFFB030 }));
}
// Crosshair.
s.push(fill(cx + cw / 2.0 - 0.5, cy + 3.0, 1.0, ch * 0.18, 0x90FFFFFF));
+2 -2
View File
@@ -94,9 +94,9 @@ pub fn summary(sim: &Sim, pic: &AirPicture, player: DVec3) -> Vec<Line> {
}
for sam in sim.sams.iter().take(shown) {
let mut text = if sam.kind.armed() {
format!("{} [{}]", sam.status(), crate::sim::roles_text(sam.roles))
format!("{} [{}]", crate::battery_view::sam_status(sam), crate::sim::roles_text(sam.roles))
} else {
sam.status()
crate::battery_view::sam_status(sam)
};
if let Some(t) = sam.gun_target.or(sam.target).and_then(|t| pic.get(t)) {
text += &format!(" > {} {}", t.kind.spec().name, distance(t.est(now).distance(sam.pos)));
+2 -29
View File
@@ -112,30 +112,6 @@ impl Comps {
pub fn whole(&self) -> bool {
self.0.iter().all(|&v| v >= 1.0)
}
/// Parts of this kind that are not whole, as "РЛС 40%, ходовая отказ".
pub fn describe(&self, kind: SamKind) -> String {
Part::ALL
.iter()
.filter(|p| p.on(kind) && self.get(**p) < 1.0)
.map(|p| match self.state(*p) {
PartState::Failed => format!("{} отказ", p.short()),
_ => format!("{} {:.0}%", p.short(), self.get(*p) * 100.0),
})
.collect::<Vec<_>>()
.join(", ")
}
/// The weakest part alone, for a one-line status (the full list is on the monitor).
pub fn worst(&self, kind: SamKind) -> String {
Part::ALL
.iter()
.filter(|p| p.on(kind) && self.get(**p) < 1.0)
.min_by(|a, b| self.get(**a).total_cmp(&self.get(**b)))
.map(|p| match self.state(*p) {
PartState::Failed => format!("{} отказ", p.short()),
_ => format!("{} {:.0}%", p.short(), self.get(*p) * 100.0),
})
.unwrap_or_default()
}
}
/// Health points an object loses at the centre of a blast.
@@ -443,9 +419,6 @@ impl Sam {
pub fn part_state(&self, p: Part) -> PartState {
if p.on(self.kind) { self.comps.state(p) } else { PartState::Ok }
}
pub fn parts_text(&self) -> String {
self.comps.describe(self.kind)
}
/// The aiming drive's share of its speed: a failed one doesn't turn at all.
pub(super) fn drive_fit(&self) -> f64 {
let h = self.part(Part::Mount);
@@ -461,7 +434,7 @@ impl Sam {
0.5 + 0.5 * self.part(Part::Gun)
}
/// Its launcher's cells still good: a damaged one holds fewer missiles.
pub(super) fn cells(&self) -> u32 {
pub fn cells(&self) -> u32 {
let Some(load) = &self.kind.spec().missile else { return 0 };
let h = self.part(Part::Launcher);
if h <= 0.0 { 0 } else { ((load.magazine as f64 * (0.4 + 0.6 * h)).ceil() as u32).clamp(1, load.magazine) }
@@ -475,7 +448,7 @@ impl Sam {
}
}
/// Ticks a reload takes: longer with a damaged launcher.
pub(super) fn reload_time(&self) -> u32 {
pub fn reload_time(&self) -> u32 {
let r = self.kind.spec().reload.max(1);
(r as f64 * (1.0 + 1.5 * (1.0 - self.part(Part::Launcher)))).round() as u32
}
+3 -51
View File
@@ -1220,57 +1220,9 @@ impl Sam {
self.yaw_vel = 0.0;
self.pitch_vel = 0.0;
}
pub fn status(&self) -> String {
let spec = self.kind.spec();
let mut text = spec.name.to_string();
if !self.alive() {
return text + " УНИЧТОЖЕН";
}
if self.moving() {
return text + " " + &self.state.name().to_lowercase();
}
match self.kind {
SamKind::Depot => return format!("{text}: {} перезарядок, RM48U {}, снятых ПВО {}", self.cargo, self.ground_stock, self.air_48n6_stock),
SamKind::Tzm => return format!("{text}: на борту {}/2, RM48U {}, снятых ПВО {}{}", self.cargo, self.ground_stock, self.air_48n6_stock, if self.return_cargo { ", везёт RM48U на склад" } else if self.job.is_some() { ", в пути" } else { "" }),
SamKind::Ew => {
let state = if self.ew_on { "ГЛУШИТ" } else if self.ew_lock { "остывает" } else { "готова" };
return format!("{text}: {state}, нагрев {:.0}%", self.heat * 100.0);
}
SamKind::Radar => {
let broken = if self.comps.whole() { String::new() } else { format!(" [{}]", self.comps.worst(self.kind)) };
return format!("{text}: целей {}{broken}", self.own.len());
}
SamKind::Light => return format!("{text}{}", if self.target.is_some() { ": в луче цель" } else { "" }),
_ => {}
}
if let Some(p) = self.preparing {
text += &format!(" · открытие ТПК №{}", p.cell + 1);
}
if self.empty && self.missiles == 0 {
text += " ЖДЁТ БК";
}
if self.health < 1.0 {
text += &format!(" ({:.0}%)", self.health * 100.0);
}
if !self.comps.whole() {
text += &format!(" [{}]", self.comps.worst(self.kind));
}
if self.reloading > 0 {
text += &format!(" перезарядка {}с", self.reloading.div_ceil(20));
} else {
if let Some(m) = &spec.missile {
if self.kind == SamKind::S400 {
text += &format!(" ПВО {} · RM48U {} / {} ячеек", self.missiles, self.ground_rounds, self.cells());
if self.ground_return { text += " · ожидает вывоза RM48U"; }
} else {
text += &format!(" ракеты {}/{}", self.missiles, m.magazine);
}
}
if spec.gun.is_some() {
text += &format!(" очереди {}", self.bursts);
}
}
text
/// The TPK cell being opened, for the presentation adapter.
pub fn preparing_cell(&self) -> Option<u32> {
self.preparing.map(|p| p.cell)
}
}
+8
View File
@@ -179,6 +179,14 @@ impl SamKind {
let s = self.spec();
s.missile.is_some() || s.gun.is_some()
}
/// Missiles its launcher's magazine holds; `None` without a launcher.
pub fn missile_magazine(self) -> Option<u32> {
self.spec().missile.as_ref().map(|m| m.magazine)
}
/// Whether it has a gun (its bursts are read by the status line).
pub fn has_gun(self) -> bool {
self.spec().gun.is_some()
}
}
impl Sam {
+31 -5
View File
@@ -1,13 +1,29 @@
//! Text for diagnostics produced by the simulation.
use crate::sim::why::{CheckReason, PartEffect};
use crate::sim::{Comps, Part, SamKind};
fn part_value(part: Part, value: f64) -> String {
if value <= 0.0 { format!("{} отказ", part.short()) }
else { format!("{} {:.0}%", part.short(), value * 100.0) }
}
/// Every worn or failed part of a system, as the monitor and the status line read it.
pub fn parts(comps: &Comps, kind: SamKind) -> String {
Part::ALL.iter().filter(|p| p.on(kind) && comps.get(**p) < 1.0)
.map(|p| part_value(*p, comps.get(*p))).collect::<Vec<_>>().join(", ")
}
/// The weakest worn or failed part alone, for a one-line status.
pub fn worst(comps: &Comps, kind: SamKind) -> String {
Part::ALL.iter().filter(|p| p.on(kind) && comps.get(**p) < 1.0)
.min_by(|a, b| comps.get(**a).total_cmp(&comps.get(**b)))
.map(|p| part_value(*p, comps.get(*p))).unwrap_or_default()
}
pub fn reason(reason: &CheckReason) -> String {
match reason {
CheckReason::Text(text) => text.clone(),
CheckReason::Parts(parts) => format!("узлы: {}", parts.iter().map(|(part, value)| {
if *value <= 0.0 { format!("{} отказ", part.short()) }
else { format!("{} {:.0}%", part.short(), value * 100.0) }
}).collect::<Vec<_>>().join(", ")),
CheckReason::Parts(parts) => format!("узлы: {}", parts.iter().map(|(part, value)| part_value(*part, *value)).collect::<Vec<_>>().join(", ")),
CheckReason::PartEffect(effect) => match effect {
PartEffect::SensorFailed => "РЛС отказала: своих измерений нет, стволы не стреляют, ракеты — по данным сети".into(),
PartEffect::SensorDamaged { fit } => format!("РЛС повреждена: дальность {:.0}%, обзор вдвое реже при худшем", fit * 100.0),
@@ -28,7 +44,17 @@ pub fn reason(reason: &CheckReason) -> String {
#[cfg(test)]
mod tests {
use super::*;
use crate::sim::Part;
use crate::sim::{Comps, Part, SamKind};
#[test]
fn renders_worn_parts_without_the_reason_prefix() {
let mut comps = Comps([1.0; 6]);
comps.0[Part::Sensor as usize] = 0.4;
comps.0[Part::Tracks as usize] = 0.0;
assert_eq!(parts(&comps, SamKind::Pantsir), "РЛС 40%, Ход отказ");
assert_eq!(worst(&comps, SamKind::Pantsir), "Ход отказ");
}
#[test]
fn damaged_simulation_produces_player_diagnostics_in_order() {
use crate::sim::{Sam, SamKind, Sim};