Files
airdef/airdef-mod/src/map.rs
T
chexit d4adbb1e47
build / mod (push) Failing after 18s
Launch typed ground strikes from carriers and isolate presentation state (#118 #88 #89)
Share read-only scene data for smoke and displayed blasts; preserve cold ejection and flight-relative recording samples. Keep finite typed depot inventory, expose per-world smoke readiness through the pinned API26 engine, and invalidate presentation resources on world changes.

Validation: core suite 156 unit tests plus 4 scenarios and the new targeted recording regression; adapter 50 unit tests, boundary check and 4 scenarios; real WASM contract 16 steps; asset pipeline and bounds checks; macOS Metal client build and HD frame.

Co-Authored-By: Codex <noreply@openai.com>
2026-11-02 22:23:09 +03:00

2583 lines
111 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! The command map (#48): a full-screen map of the land with the systems, the objects, the launch sites
//! the radars found and the tracks the player's network holds; a placement editor for the layout before
//! a battle; the doctrine's guards and sector picked on the map.
//!
//! The map shows what the network knows (`Sim::picture`: the last measurement and the forecast of each
//! track), never the true drones, unless the sandbox's `truth` is on, and then it says so. The terrain
//! comes from the game as tiles (`render::TerrainShape`): the mod only says which, and the game scans the
//! loaded chunks within a budget; land it hasn't got is drawn as unknown.
use crate::panel::distance;
use crate::sim::{self, Class, LowSensor, Sam, SamKind, Sim, doctrine::Doctrine, Track, strike::SiteState};
use crate::{AirDef, say};
use glam::DVec3;
use horizon_mod_sdk::render::{self, CanvasEvent, FillShape, Point, QuadShape, Rect, Shape, TerrainShape, TextShape};
use std::collections::HashMap;
use std::f32::consts::TAU;
const FILTERS: [&str; 9] = ["рельеф", "системы", "объекты", "цели сети", "следы", "пусковые", "дальности", "обзор РЛС", "заливка"];
const F_TERRAIN: usize = 0;
const F_SAMS: usize = 1;
const F_OBJECTS: usize = 2;
const F_TRACKS: usize = 3;
const F_TRAILS: usize = 4;
const F_SITES: usize = 5;
const F_RINGS: usize = 6;
const F_VIEW: usize = 7;
const F_TINT: usize = 8;
/// Classes of systems for the filter: missile systems, guns, radars, the rear.
const SYS_CLASSES: [&str; 4] = ["ЗРК", "ЗАК", "РЛС", "тыл"];
/// Classes of the network's targets, by the speed of the track (the network doesn't know what a target is).
const TGT_CLASSES: [&str; 5] = ["Д", "Г", "К", "С", "Б"];
/// Speed (blocks a tick) below which a track is of the class: drones, jets, cruise, supersonic, the rest ballistic.
const TGT_SPEED: [f64; 4] = [0.8, 1.8, 3.0, 6.5];
/// A label line's height, pixels the markers merge within, how far from the pointer labels are kept at
/// a low zoom, and the most labels at once.
const LH: f32 = 9.0;
const CLUSTER_R: f32 = 9.0;
const MAX_LABELS: usize = 70;
/// Ticks a radar's computed coverage edge lives, and how many are recomputed in a redraw.
const RIM_REFRESH: u64 = 100;
const RIMS_PER_FRAME: usize = 3;
/// The most dashes of coverage edges in a redraw, the most cells of the tint, and the most land questions for one tint.
const RIM_DASHES: usize = 2400;
const TINT_CELLS: f32 = 1000.0;
const TINT_ASKS: usize = 12_000;
const SCN_ROWS: usize = 6;
/// Blocks per pixel limits: the whole raid, and one vehicle.
const SCALE_MIN: f64 = 0.04;
const SCALE_MAX: f64 = 24.0;
const TRAIL_POINTS: usize = 90;
/// Ticks between trail samples.
const SAMPLE: u64 = 10;
/// Pixels within which the pointer picks something.
const PICK_R: f32 = 9.0;
const DRAFT_UNDO: usize = 40;
const GREEN: u32 = 0xFF80FF90;
const WHITE: u32 = 0xFFFFFFFF;
const GREY: u32 = 0xFFB0B0B0;
const YELLOW: u32 = 0xFFFFE070;
const RED: u32 = 0xFFFF5050;
const CYAN: u32 = 0xFF9FE0FF;
const ORANGE: u32 = 0xFFFFA040;
const PANEL: u32 = 0xD0101814;
#[derive(Clone, Copy, PartialEq, Debug)]
enum Sel {
Sam(u32),
Object(usize),
Site(u32),
Track(u32),
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum Pick {
None,
Sam(SamKind),
Object,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum Mode {
View,
/// Pick the objects the system guards.
Guard(u32),
/// Pick the sector's centre, then its width.
Sector(u32, Option<f64>),
Editor,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum Act {
Filter(usize),
Editor,
Pick(Pick),
Confirm,
Cancel,
Undo,
Guard,
Sector,
SectorOff,
Reserve,
Salvo,
Role(u8),
ResetDoc,
Strike(u32),
Centre,
Follow,
Rotate,
Delete,
Close,
Player,
SysClass(usize),
TgtClass(usize),
Tab(usize),
Panel,
NameFocus,
SaveScn,
LoadScn(usize),
ScnPage(i32),
}
/// A system in the draft layout: an existing one (by id) or one to be built.
#[derive(Clone, Debug)]
struct DSam {
id: Option<u32>,
kind: SamKind,
pos: DVec3,
heading: f64,
gone: bool,
}
#[derive(Clone, Debug)]
struct DObj {
idx: Option<usize>,
pos: DVec3,
gone: bool,
}
#[derive(Clone, Debug, Default)]
struct Draft {
sams: Vec<DSam>,
objs: Vec<DObj>,
}
enum Drag {
Pan { from: (f32, f32), centre: (f64, f64), moved: bool },
Sam(usize),
Obj(usize),
}
struct Btn {
rect: [f32; 4],
act: Act,
}
/// A coverage edge worked out: how far a low flyer is seen along each ray before the land hides it.
struct Rim {
tick: u64,
pos: DVec3,
reach: f64,
terrain: bool,
d: Vec<f32>,
}
/// The coverage tint of a view, kept while the view and the layout stay the same: runs of cells (x, y, w, h, colour).
#[derive(Default)]
struct Tint {
key: u64,
runs: Vec<([f32; 4], u32)>,
}
/// Markers that merged into one at this zoom: where, and what a click on them zooms to.
struct Cluster {
c: (f32, f32),
}
/// A label waiting for a place.
struct Lab {
text: String,
w: f32,
at: (f32, f32),
r: f32,
col: u32,
prio: f32,
}
/// What the map keeps between frames.
pub struct MapUi {
pub open: bool,
size: (f32, f32),
cursor: (f32, f32),
centre: (f64, f64),
scale: f64,
placed: bool,
drag: Option<Drag>,
sel: Option<Sel>,
follow: bool,
mode: Mode,
filters: [bool; 9],
sclass: [bool; 4],
tclass: [bool; 5],
/// The left panel's page (layers, filters, scenarios) and whether it is folded away.
tab: usize,
folded: bool,
/// The layout's scale for the window (1 small, up to 1.4 large).
u: f32,
/// Scenario buttons: the name being typed, whether the field takes the keys, the names saved, the page of them,
/// and what a second click confirms (a delete, an overwrite, a load from another world).
name: String,
name_focus: bool,
scn: Vec<String>,
scn_page: usize,
confirm: Option<(Act, String)>,
rims: HashMap<u32, Rim>,
tint: Tint,
clusters: Vec<Cluster>,
/// Where panels are, so labels keep clear of them.
blocked: Vec<[f32; 4]>,
widths: HashMap<String, f32>,
trails: HashMap<u32, Vec<(f32, f32)>>,
seen: HashMap<u32, u64>,
sampled: u64,
draft: Draft,
history: Vec<Draft>,
pick: Pick,
heading: f64,
ed_sel: Option<EdSel>,
note: Option<(String, u64)>,
dirty: bool,
drawn: u64,
buttons: Vec<Btn>,
chunks_at: u64,
close: bool,
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum EdSel {
Sam(usize),
Obj(usize),
}
impl Default for MapUi {
fn default() -> Self {
MapUi {
open: false,
size: (480.0, 270.0),
cursor: (0.0, 0.0),
centre: (0.0, 0.0),
scale: 0.5,
placed: false,
drag: None,
sel: None,
follow: false,
mode: Mode::View,
filters: [true, true, true, true, true, true, true, true, false],
sclass: [true; 4],
tclass: [true; 5],
tab: 0,
folded: false,
u: 1.0,
name: String::new(),
name_focus: false,
scn: Vec::new(),
scn_page: 0,
confirm: None,
rims: HashMap::new(),
tint: Tint::default(),
clusters: Vec::new(),
blocked: Vec::new(),
widths: HashMap::new(),
trails: HashMap::new(),
seen: HashMap::new(),
sampled: 0,
draft: Draft::default(),
history: Vec::new(),
pick: Pick::None,
heading: 0.0,
ed_sel: None,
note: None,
dirty: true,
drawn: u64::MAX,
buttons: Vec::new(),
chunks_at: 0,
close: false,
}
}
}
fn pt(x: f32, y: f32) -> Point {
Point { x, y }
}
fn fill(x: f32, y: f32, w: f32, h: f32, color: u32) -> Shape {
Shape::Fill(FillShape { rect: Rect { x, y, w, h }, color })
}
fn text(t: impl Into<String>, x: f32, y: f32, color: u32) -> Shape {
Shape::Text(TextShape { text: t.into(), at: pt(x, y), color: color & 0xFFFFFF, centered: false, shadow: true })
}
fn text_c(t: impl Into<String>, x: f32, y: f32, color: u32) -> Shape {
Shape::Text(TextShape { text: t.into(), at: pt(x, y), color: color & 0xFFFFFF, centered: true, shadow: true })
}
/// A line of `w` pixels.
fn line(a: (f32, f32), b: (f32, f32), w: f32, color: u32) -> Shape {
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let len = dx.hypot(dy).max(0.001);
let (nx, ny) = (-dy / len * w / 2.0, dx / len * w / 2.0);
Shape::Quad(QuadShape { corners: (pt(a.0 + nx, a.1 + ny), pt(b.0 + nx, b.1 + ny), pt(b.0 - nx, b.1 - ny), pt(a.0 - nx, a.1 - ny)), color })
}
fn frame(x: f32, y: f32, w: f32, h: f32, b: f32, color: u32) -> [Shape; 4] {
[fill(x, y, w, b, color), fill(x, y + h - b, w, b, color), fill(x, y, b, h, color), fill(x + w - b, y, b, h, color)]
}
fn alpha(rgb: u32, a: f32) -> u32 {
(((a.clamp(0.0, 1.0) * 255.0) as u32) << 24) | (rgb & 0xFFFFFF)
}
/// A diamond, a square and the like around (x, y).
fn diamond(x: f32, y: f32, r: f32, color: u32) -> Shape {
Shape::Quad(QuadShape { corners: (pt(x, y - r), pt(x + r, y), pt(x, y + r), pt(x - r, y)), color })
}
/// The direction a heading looks along on the map (x east, z south): `heading_of`'s inverse.
fn dir_of(h: f64) -> (f64, f64) {
(-h.sin(), -h.cos())
}
impl MapUi {
fn to_screen(&self, x: f64, z: f64) -> (f32, f32) {
(
(self.size.0 as f64 / 2.0 + (x - self.centre.0) * self.scale) as f32,
(self.size.1 as f64 / 2.0 + (z - self.centre.1) * self.scale) as f32,
)
}
fn to_world(&self, p: (f32, f32)) -> (f64, f64) {
(
self.centre.0 + (p.0 as f64 - self.size.0 as f64 / 2.0) / self.scale,
self.centre.1 + (p.1 as f64 - self.size.1 as f64 / 2.0) / self.scale,
)
}
fn on_screen(&self, p: (f32, f32), margin: f32) -> bool {
p.0 > -margin && p.1 > -margin && p.0 < self.size.0 + margin && p.1 < self.size.1 + margin
}
fn note(&mut self, tick: u64, s: impl Into<String>) {
self.note = Some((s.into(), tick + 100));
self.dirty = true;
}
/// Remembers where the network's tracks are, every few ticks, for the trails.
pub fn sample(&mut self, sim: &Sim) {
if sim.tick < self.sampled {
self.trails.clear();
self.seen.clear();
}
if sim.tick < self.sampled + SAMPLE {
return;
}
self.sampled = sim.tick;
for (id, t) in sim.picture() {
// Only measurements: a forecast is not a place the target has been.
if t.age(sim.tick) > SAMPLE * 2 {
continue;
}
let trail = self.trails.entry(id).or_default();
let p = (t.pos.x as f32, t.pos.z as f32);
if trail.last().is_none_or(|l| (l.0 - p.0).hypot(l.1 - p.1) > 4.0) {
trail.push(p);
if trail.len() > TRAIL_POINTS {
trail.remove(0);
}
}
self.seen.insert(id, sim.tick);
}
let now = sim.tick;
self.seen.retain(|_, t| now.saturating_sub(*t) < 1200);
let seen = &self.seen;
self.trails.retain(|id, _| seen.contains_key(id));
}
fn enter_editor(&mut self) {
self.draft = Draft::default();
self.history.clear();
self.mode = Mode::Editor;
self.pick = Pick::None;
self.ed_sel = None;
self.sel = None;
self.dirty = true;
}
fn push_history(&mut self) {
self.history.push(self.draft.clone());
if self.history.len() > DRAFT_UNDO {
self.history.remove(0);
}
}
}
impl MapUi {
/// A line's width in GUI pixels; the game is asked once for each text.
fn tw(&mut self, t: &str) -> f32 {
if let Some(w) = self.widths.get(t) {
return *w;
}
if self.widths.len() > 1500 {
self.widths.clear();
}
let w = render::text_width(t);
self.widths.insert(t.to_string(), w);
w
}
/// The names of the saved scenarios, and a name for the next save that no scenario has.
fn refresh_scenarios(&mut self) {
self.scn = crate::scenario::saved_names();
self.scn_page = self.scn_page.min(self.scn.len().saturating_sub(1) / SCN_ROWS);
if self.name.is_empty() || self.scn.contains(&self.name) && !self.name_focus {
self.name = (1..).map(|n| format!("map-{n}")).find(|n| !self.scn.contains(n)).unwrap_or_default();
}
}
}
/// The class of a system in the filter: 0 missile systems, 1 guns, 2 radars, 3 the rear.
fn sys_class(k: SamKind) -> usize {
if k.armed() {
if k == SamKind::Gepard { 1 } else { 0 }
} else if k.spec().sensor > 0.0 {
2
} else {
3
}
}
/// A name that fits beside a marker.
fn short_name(k: SamKind) -> &'static str {
match k {
SamKind::Radar => "РЛС",
SamKind::Depot => "Склад",
SamKind::Tzm => "ТЗМ",
SamKind::Ew => "РЭБ",
SamKind::Light => "Прож.",
SamKind::Pantsir => "Панцирь",
SamKind::IrisT => "IRIS-T",
SamKind::S400 => "С-400",
SamKind::S500 => "С-500",
SamKind::Buk => "Бук",
SamKind::Tor => "Тор",
SamKind::Gepard => "Гепард",
_ => k.name(),
}
}
/// The class of a track by its speed.
fn tgt_class(t: &Track) -> usize {
let v = t.vel.length();
TGT_SPEED.iter().position(|&m| v < m).unwrap_or(TGT_SPEED.len())
}
/// Markers within `r` pixels of the first of a group go with it: the groups, as indices into `pos`.
fn group(pos: &[(f32, f32)], r: f32) -> Vec<Vec<usize>> {
let r2 = r * r;
let mut g: Vec<Vec<usize>> = Vec::new();
'next: for (i, p) in pos.iter().enumerate() {
for grp in g.iter_mut() {
let a = pos[grp[0]];
if (a.0 - p.0).powi(2) + (a.1 - p.1).powi(2) <= r2 {
grp.push(i);
continue 'next;
}
}
g.push(vec![i]);
}
g
}
/// The groups of markers: those in `solo` stand alone; the rest merge when `cluster` is on.
fn groups_of(pos: &[(f32, f32)], solo: &[bool], r: f32, cluster: bool) -> Vec<Vec<usize>> {
let mut g: Vec<Vec<usize>> = (0..pos.len()).filter(|&i| solo[i]).map(|i| vec![i]).collect();
let rest: Vec<usize> = (0..pos.len()).filter(|&i| !solo[i]).collect();
if !cluster {
g.extend(rest.into_iter().map(|i| vec![i]));
return g;
}
let ps: Vec<(f32, f32)> = rest.iter().map(|&i| pos[i]).collect();
g.extend(group(&ps, r).into_iter().map(|grp| grp.into_iter().map(|k| rest[k]).collect::<Vec<_>>()));
g
}
/// Several markers as one: a box with their number, in the middle of them; a click zooms in on it.
fn draw_cluster(ui: &mut MapUi, s: &mut Vec<Shape>, taken: &mut Vec<[f32; 4]>, members: &[(f32, f32)], col: u32) {
let n = members.len() as f32;
let c = (members.iter().map(|m| m.0).sum::<f32>() / n, members.iter().map(|m| m.1).sum::<f32>() / n);
let label = members.len().to_string();
let half = (ui.tw(&label) / 2.0 + 3.0).max(7.0);
s.push(fill(c.0 - half - 1.0, c.1 - 6.0, half * 2.0 + 2.0, 12.0, col));
s.push(fill(c.0 - half, c.1 - 5.0, half * 2.0, 10.0, 0xFF101810));
s.push(text_c(label, c.0, c.1 - 4.0, col));
taken.push([c.0 - half - 1.0, c.1 - 6.0, half * 2.0 + 2.0, 12.0]);
ui.clusters.push(Cluster { c });
}
/// Asks for a label beside a marker; near the pointer it is kept, far from it at a low zoom it isn't.
fn add_lab(ui: &mut MapUi, labs: &mut Vec<Lab>, text: String, at: (f32, f32), r: f32, col: u32, chosen: bool) {
let d = (at.0 - ui.cursor.0).hypot(at.1 - ui.cursor.1);
let attn = if ui.scale < 0.15 {
90.0
} else if ui.scale < 0.6 {
200.0
} else {
f32::MAX
};
if !chosen && d > attn {
return;
}
let w = ui.tw(&text);
labs.push(Lab { text, w, at, r, col, prio: if chosen { -1.0e6 } else { d } });
}
fn overlap(a: [f32; 4], b: [f32; 4]) -> bool {
a[0] < b[0] + b[2] && a[0] + a[2] > b[0] && a[1] < b[1] + b[3] && a[1] + a[3] > b[1]
}
/// Puts the labels where nothing else is: the selected first, then those nearest the pointer; each beside its
/// marker (right, left, above, below), or not at all. `taken` holds the panels and the markers.
fn place_labels(size: (f32, f32), mut labs: Vec<Lab>, mut taken: Vec<[f32; 4]>, out: &mut Vec<Shape>) {
labs.sort_by(|a, b| a.prio.total_cmp(&b.prio));
let mut put = 0;
for l in labs {
if put >= MAX_LABELS {
break;
}
let (x, y) = l.at;
let gap = l.r + 2.0;
let tries = [
(x + gap, y - LH / 2.0),
(x - gap - l.w, y - LH / 2.0),
(x - l.w / 2.0, y - gap - LH),
(x - l.w / 2.0, y + gap),
(x + gap, y + 1.0),
(x + gap, y - LH - 1.0),
];
for (tx, ty) in tries {
let r = [tx, ty, l.w, LH];
if tx < 0.0 || ty < 0.0 || tx + l.w > size.0 || ty + LH > size.1 {
continue;
}
if taken.iter().any(|t| overlap(r, [t[0] - 1.0, t[1] - 1.0, t[2] + 2.0, t[3] + 2.0])) {
continue;
}
out.push(text(l.text.as_str(), tx, ty, l.col));
taken.push(r);
put += 1;
break;
}
}
}
/// Whether a system reaches the point (its weapons, on the plane).
fn reaches(kind: SamKind, pos: DVec3, p: DVec3) -> bool {
kind.range() > 0.0 && (pos.x - p.x).hypot(pos.z - p.z) <= kind.range()
}
fn class_name(c: sim::sites::SiteClass) -> &'static str {
match c {
sim::sites::SiteClass::Ramp => "рампа дронов",
sim::sites::SiteClass::Launcher => "пусковая ракет",
sim::sites::SiteClass::Battery => "батарея баллистических",
}
}
impl AirDef {
/// Opens the map (the key, or the menu).
pub(crate) fn map_toggle(&mut self) {
if self.map.open {
self.map_close();
return;
}
if self.presentation.playback().is_some() {
say("Карта: сначала закройте повтор");
return;
}
let Some(p) = crate::player() else { return };
let ui = &mut self.map;
ui.open = true;
ui.mode = Mode::View;
ui.drag = None;
ui.size = render::gui_size();
if !ui.placed {
ui.centre = (p.x, p.z);
ui.placed = true;
ui.folded = ui.size.0 < 520.0;
}
ui.refresh_scenarios();
ui.dirty = true;
ui.drawn = u64::MAX;
render::open_canvas();
}
pub(crate) fn map_close(&mut self) {
if self.map.open {
render::close_canvas();
render::set_canvas(&[]);
}
self.map.open = false;
self.map.draft = Draft::default();
self.map.mode = Mode::View;
self.map.drag = None;
}
/// Once a frame while the map is open.
pub(crate) fn map_frame(&mut self) {
if !self.map.open {
return;
}
if !render::canvas_open() {
// The game closed it (the world was left, or it was not the time).
self.map.open = false;
self.map.draft = Draft::default();
self.map.mode = Mode::View;
return;
}
let mut ui = std::mem::take(&mut self.map);
for ev in render::canvas_events() {
self.map_event(&mut ui, ev);
if ui.close {
break;
}
}
if ui.close {
ui.close = false;
self.map = ui;
self.map_close();
return;
}
if ui.open {
if ui.follow
&& let Some(Sel::Track(id)) = ui.sel
&& let Some(t) = self.sim.picture().get(&id)
{
let e = t.est(self.sim.tick);
ui.centre = (e.x, e.z);
ui.dirty = true;
}
// The data moves at the sim's pace: a few redraws a second even when nothing is touched.
let step = self.sim.tick / 2;
if ui.dirty || ui.drawn != step {
ui.dirty = false;
ui.drawn = step;
let shapes = self.map_shapes(&mut ui);
render::set_canvas(&shapes);
}
}
self.map = ui;
}
fn ground_y(&mut self, x: f64, z: f64) -> Option<f64> {
self.ground.at(DVec3::new(x, 0.0, z), self.sim.tick)
}
fn map_event(&mut self, ui: &mut MapUi, ev: CanvasEvent) {
match ev {
CanvasEvent::Resized((w, h)) => {
ui.size = (w, h);
ui.dirty = true;
}
CanvasEvent::Moved(p) => {
ui.cursor = (p.x, p.y);
ui.dirty = true;
match &mut ui.drag {
Some(Drag::Pan { from, centre, moved }) => {
let (dx, dy) = (p.x - from.0, p.y - from.1);
if dx.hypot(dy) > 3.0 {
*moved = true;
}
if *moved {
ui.centre = (centre.0 - dx as f64 / ui.scale, centre.1 - dy as f64 / ui.scale);
ui.follow = false;
}
}
Some(Drag::Sam(i)) => {
let i = *i;
let (x, z) = ui.to_world((p.x, p.y));
if let Some(y) = self.ground_y(x, z)
&& let Some(d) = ui.draft.sams.get_mut(i)
{
d.pos = DVec3::new(x, y, z);
}
}
Some(Drag::Obj(i)) => {
let i = *i;
let (x, z) = ui.to_world((p.x, p.y));
if let Some(y) = self.ground_y(x, z)
&& let Some(d) = ui.draft.objs.get_mut(i)
{
d.pos = DVec3::new(x, y, z);
}
}
None => {}
}
}
CanvasEvent::Scrolled(s) => {
let at = (s.at.x, s.at.y);
let before = ui.to_world(at);
ui.scale = (ui.scale * 1.25f64.powf(s.steps as f64)).clamp(SCALE_MIN, SCALE_MAX);
// The point under the pointer stays under it.
ui.centre = (before.0 - (at.0 as f64 - ui.size.0 as f64 / 2.0) / ui.scale, before.1 - (at.1 as f64 - ui.size.1 as f64 / 2.0) / ui.scale);
ui.follow = false;
ui.dirty = true;
}
CanvasEvent::Pressed(b) => {
let at = (b.at.x, b.at.y);
ui.cursor = at;
ui.dirty = true;
if b.button == 0 {
let hit = ui.buttons.iter().find(|bt| at.0 >= bt.rect[0] && at.0 <= bt.rect[0] + bt.rect[2] && at.1 >= bt.rect[1] && at.1 <= bt.rect[1] + bt.rect[3]).map(|bt| bt.act);
if let Some(act) = hit {
self.map_act(ui, act);
return;
}
ui.name_focus = false;
ui.confirm = None;
}
match (b.button, ui.mode) {
(0, Mode::Editor) => self.editor_press(ui, at),
(0 | 2, _) => {
ui.drag = Some(Drag::Pan { from: at, centre: ui.centre, moved: false });
}
(1, Mode::Editor) => self.editor_remove_at(ui, at),
(1, _) => self.map_right(ui, at),
_ => {}
}
}
CanvasEvent::Released(b) => {
let at = (b.at.x, b.at.y);
ui.cursor = at;
ui.dirty = true;
let drag = ui.drag.take();
match drag {
Some(Drag::Pan { moved: false, .. }) if b.button == 0 => self.map_click(ui, at),
Some(Drag::Sam(_) | Drag::Obj(_)) => {}
_ => {}
}
}
CanvasEvent::Key(k) => self.map_key(ui, &k),
}
}
fn map_key(&mut self, ui: &mut MapUi, key: &str) {
ui.dirty = true;
// The name of a scenario being typed takes every key.
if ui.name_focus {
match key {
"key.keyboard.escape" => ui.name_focus = false,
"key.keyboard.enter" | "key.keyboard.keypad.enter" => self.map_act(ui, Act::SaveScn),
"key.keyboard.backspace" | "key.keyboard.delete" => {
ui.name.pop();
}
"key.keyboard.minus" if ui.name.len() < 32 => ui.name.push('-'),
k => {
if let Some(c) = k.strip_prefix("key.keyboard.")
&& c.len() == 1
&& c.as_bytes()[0].is_ascii_alphanumeric()
&& ui.name.len() < 32
{
ui.name.push(c.as_bytes()[0].to_ascii_lowercase() as char);
}
}
}
return;
}
let step = (60.0 / ui.scale).max(2.0);
match key {
"key.keyboard.escape" => {
if ui.drag.is_some() {
ui.drag = None;
} else if ui.mode == Mode::Editor {
if ui.pick != Pick::None || ui.ed_sel.is_some() {
ui.pick = Pick::None;
ui.ed_sel = None;
} else {
ui.mode = Mode::View;
ui.draft = Draft::default();
ui.note(self.sim.tick, "Расстановка отменена");
}
} else if ui.mode != Mode::View {
ui.mode = Mode::View;
} else if ui.sel.is_some() {
ui.sel = None;
ui.follow = false;
} else {
ui.close = true;
}
}
"key.keyboard.m" => {
if ui.mode == Mode::Editor && (!ui.draft.sams.is_empty() || !ui.draft.objs.is_empty()) && self.draft_changed(ui) {
ui.note(self.sim.tick, "Есть неподтверждённые изменения: Enter подтвердить, Esc отмена");
return;
}
ui.close = true;
}
"key.keyboard.left" => ui.centre.0 -= step,
"key.keyboard.right" => ui.centre.0 += step,
"key.keyboard.up" => ui.centre.1 -= step,
"key.keyboard.down" => ui.centre.1 += step,
"key.keyboard.equal" => self.map_zoom_centre(ui, 1.25),
"key.keyboard.minus" => self.map_zoom_centre(ui, 0.8),
"key.keyboard.c" => self.map_act(ui, Act::Player),
"key.keyboard.e" => self.map_act(ui, Act::Editor),
"key.keyboard.enter" if ui.mode == Mode::Editor => self.map_act(ui, Act::Confirm),
"key.keyboard.z" if ui.mode == Mode::Editor => self.map_act(ui, Act::Undo),
"key.keyboard.r" if ui.mode == Mode::Editor => self.map_act(ui, Act::Rotate),
"key.keyboard.delete" | "key.keyboard.backspace" if ui.mode == Mode::Editor => self.map_act(ui, Act::Delete),
"key.keyboard.f" => self.map_act(ui, Act::Follow),
k if k.len() == 14 && k.starts_with("key.keyboard.") && k.as_bytes()[13].is_ascii_digit() && k.as_bytes()[13] != b'0' => {
let n = (k.as_bytes()[13] - b'1') as usize;
if n < FILTERS.len() {
ui.filters[n] = !ui.filters[n];
}
}
"key.keyboard.s" => {
ui.folded = false;
ui.tab = 2;
ui.refresh_scenarios();
}
"key.keyboard.n" if ui.tab == 2 && !ui.folded => ui.name_focus = true,
"key.keyboard.tab" => {
ui.folded = !ui.folded;
}
_ => {}
}
}
fn map_zoom_centre(&mut self, ui: &mut MapUi, k: f64) {
ui.scale = (ui.scale * k).clamp(SCALE_MIN, SCALE_MAX);
}
/// The draft differs from the layout.
fn draft_changed(&self, ui: &MapUi) -> bool {
let d = &ui.draft;
d.sams.iter().any(|s| match s.id {
None => !s.gone,
Some(id) => s.gone || self.sim.sams.iter().find(|x| x.id == id).is_none_or(|x| x.pos.distance(s.pos) > 0.01 || (x.heading - s.heading).abs() > 1e-6),
}) || d.objs.iter().any(|o| match o.idx {
None => !o.gone,
Some(i) => o.gone || self.sim.targets.get(i).is_none_or(|t| t.distance(o.pos) > 0.01),
})
}
/// Loads the layout into the draft the first time the editor needs it.
fn ensure_draft(&mut self, ui: &mut MapUi) {
if !ui.draft.sams.is_empty() || !ui.draft.objs.is_empty() {
return;
}
ui.draft.sams = self.sim.sams.iter().map(|s| DSam { id: Some(s.id), kind: s.kind, pos: s.pos, heading: s.heading, gone: false }).collect();
ui.draft.objs = self.sim.targets.iter().enumerate().map(|(i, p)| DObj { idx: Some(i), pos: *p, gone: false }).collect();
}
fn battle(&self) -> bool {
!self.sim.drones.is_empty() || !self.sim.queue.is_empty() || self.sim.planning()
}
fn map_act(&mut self, ui: &mut MapUi, act: Act) {
ui.dirty = true;
let tick = self.sim.tick;
if act != Act::NameFocus {
ui.name_focus = false;
}
if !matches!(act, Act::SaveScn | Act::LoadScn(_)) {
ui.confirm = None;
}
match act {
Act::SysClass(i) => ui.sclass[i] = !ui.sclass[i],
Act::TgtClass(i) => ui.tclass[i] = !ui.tclass[i],
Act::Tab(i) => {
ui.tab = i;
if i == 2 {
ui.refresh_scenarios();
}
}
Act::Panel => ui.folded = !ui.folded,
Act::NameFocus => ui.name_focus = true,
Act::ScnPage(d) => {
let pages = ui.scn.len().div_ceil(SCN_ROWS).max(1);
ui.scn_page = (ui.scn_page as i32 + d).clamp(0, pages as i32 - 1) as usize;
}
Act::SaveScn => {
let name = ui.name.clone();
if ui.scn.contains(&name) && !matches!(&ui.confirm, Some((Act::SaveScn, n)) if *n == name) {
ui.confirm = Some((Act::SaveScn, name));
ui.note(tick, "Такое имя уже есть: нажмите ещё раз, чтобы перезаписать");
return;
}
ui.confirm = None;
match self.scenario_command(&["save", &name]) {
Ok(m) => {
say(&m);
ui.note(tick, m);
}
Err(e) => ui.note(tick, e),
}
ui.refresh_scenarios();
}
Act::LoadScn(i) => {
let Some(name) = ui.scn.get(i).cloned() else { return };
let again = matches!(&ui.confirm, Some((Act::LoadScn(k), _)) if *k == i);
let args: Vec<&str> = if again { vec!["load", &name, "force"] } else { vec!["load", &name] };
match self.scenario_command(&args) {
Ok(m) => {
say(&m);
ui.confirm = None;
ui.sel = None;
ui.follow = false;
ui.draft = Draft::default();
ui.history.clear();
ui.mode = Mode::View;
ui.pick = Pick::None;
ui.ed_sel = None;
ui.trails.clear();
ui.rims.clear();
ui.note(tick, m);
}
Err(e) if e.contains("другом мире") && !again => {
ui.confirm = Some((Act::LoadScn(i), name));
ui.note(tick, "Сценарий сделан в другом мире: нажмите ещё раз, чтобы загрузить всё равно");
}
Err(e) => {
ui.confirm = None;
ui.note(tick, e);
}
}
}
Act::Filter(i) => ui.filters[i] = !ui.filters[i],
Act::Close => {
ui.close = true;
}
Act::Player => {
if let Some(p) = crate::player() {
ui.centre = (p.x, p.z);
ui.follow = false;
}
}
Act::Editor => {
if ui.mode == Mode::Editor {
if self.draft_changed(ui) {
ui.note(tick, "Есть неподтверждённые изменения: Enter подтвердить, «Отмена» сбросить");
} else {
ui.mode = Mode::View;
ui.draft = Draft::default();
}
} else if self.battle() {
ui.note(tick, "Бой идёт: расстановка закрыта до конца налёта");
} else {
ui.enter_editor();
self.ensure_draft(ui);
}
}
Act::Pick(p) => {
ui.pick = if ui.pick == p { Pick::None } else { p };
ui.ed_sel = None;
}
Act::Cancel => {
ui.draft = Draft::default();
ui.history.clear();
ui.mode = Mode::View;
ui.pick = Pick::None;
ui.note(tick, "Изменения отменены, ничего не построено");
}
Act::Undo => {
if let Some(d) = ui.history.pop() {
ui.draft = d;
ui.ed_sel = None;
}
}
Act::Rotate => {
let step = std::f64::consts::FRAC_PI_4;
match ui.ed_sel {
Some(EdSel::Sam(i)) => {
ui.push_history();
if let Some(d) = ui.draft.sams.get_mut(i) {
d.heading += step;
}
}
_ => ui.heading += step,
}
}
Act::Delete => {
if let Some(s) = ui.ed_sel.take() {
ui.push_history();
match s {
EdSel::Sam(i) => remove_dsam(&mut ui.draft, i),
EdSel::Obj(i) => remove_dobj(&mut ui.draft, i),
}
}
}
Act::Confirm => self.commit_draft(ui),
Act::Centre => {
if let Some(p) = self.sel_pos(ui) {
ui.centre = (p.x, p.z);
}
}
Act::Follow => {
if matches!(ui.sel, Some(Sel::Track(_))) {
ui.follow = !ui.follow;
}
}
Act::Guard => {
if let Some(Sel::Sam(id)) = ui.sel {
ui.mode = if ui.mode == Mode::Guard(id) { Mode::View } else { Mode::Guard(id) };
}
}
Act::Sector => {
if let Some(Sel::Sam(id)) = ui.sel {
ui.mode = if matches!(ui.mode, Mode::Sector(i, _) if i == id) { Mode::View } else { Mode::Sector(id, None) };
}
}
Act::SectorOff => {
if let Some(i) = self.sel_sam(ui) {
self.edit_doctrine(i, |d| d.sector = None);
}
ui.mode = Mode::View;
}
Act::Reserve => {
if let Some(i) = self.sel_sam(ui) {
self.edit_doctrine(i, |d| d.reserve = [0, 1, 2, 4, 8, 16].into_iter().find(|&r| r > d.reserve).unwrap_or(0));
}
}
Act::Salvo => {
if let Some(i) = self.sel_sam(ui) {
self.edit_doctrine(i, |d| d.salvo = d.salvo.next());
}
}
Act::ResetDoc => {
if let Some(i) = self.sel_sam(ui) {
self.edit_doctrine(i, |d| *d = Doctrine::default());
}
ui.mode = Mode::View;
}
Act::Role(bit) => {
if let Some(i) = self.sel_sam(ui) {
let s = &mut self.sim.sams[i];
s.roles ^= bit;
s.target = None;
s.gun_target = None;
self.dirty = true;
}
}
Act::Strike(site) => {
let Some(p) = crate::player() else { return };
let mut out = sim::Out::default();
match self.sim.order_strike(site, DVec3::new(p.x, p.y, p.z), &mut out) {
Ok(m) => {
// The stock went down: the durable state must not forget it (#113).
self.dirty = true;
say(&m);
ui.note(tick, "Ударная ракета пошла");
}
Err(e) => {
ui.note(tick, e.clone());
say(&e);
}
}
self.emit(out);
}
}
}
fn sel_sam(&self, ui: &MapUi) -> Option<usize> {
match ui.sel {
Some(Sel::Sam(id)) => self.sim.sams.iter().position(|s| s.id == id),
_ => None,
}
}
fn sel_pos(&self, ui: &MapUi) -> Option<DVec3> {
match ui.sel? {
Sel::Sam(id) => self.sim.sams.iter().find(|s| s.id == id).map(|s| s.pos),
Sel::Object(i) => self.sim.targets.get(i).copied(),
Sel::Site(id) => self.sim.strikes.get(id).and_then(|k| k.est.filter(|e| e.fix)).map(|e| DVec3::new(e.pos.x, 0.0, e.pos.y)),
Sel::Track(id) => self.sim.picture().get(&id).map(|t| t.est(self.sim.tick)),
}
}
/// What is under the pointer: systems, objects, launch sites, then tracks.
fn pick_at(&self, ui: &MapUi, p: (f32, f32)) -> Option<Sel> {
let near = |w: DVec3| {
let s = ui.to_screen(w.x, w.z);
(s.0 - p.0).hypot(s.1 - p.1) <= PICK_R
};
if ui.filters[F_SAMS] {
if let Some(s) = self.sim.sams.iter().find(|s| near(s.pos) && ui.sclass[sys_class(s.kind)]) {
return Some(Sel::Sam(s.id));
}
}
if ui.filters[F_OBJECTS] {
if let Some(i) = self.sim.targets.iter().position(|t| near(*t)) {
return Some(Sel::Object(i));
}
}
if ui.filters[F_SITES] {
for k in &self.sim.strikes.known {
if let Some(e) = k.est.filter(|e| e.fix)
&& near(DVec3::new(e.pos.x, 0.0, e.pos.y))
{
return Some(Sel::Site(k.site));
}
}
}
if ui.filters[F_TRACKS] {
let now = self.sim.tick;
let pic = self.sim.picture();
let mut best: Option<(f32, u32)> = None;
for (id, t) in &pic {
if !ui.tclass[tgt_class(t)] {
continue;
}
let e = t.est(now);
let s = ui.to_screen(e.x, e.z);
let d = (s.0 - p.0).hypot(s.1 - p.1);
if d <= PICK_R + 2.0 && best.is_none_or(|b| d < b.0) {
best = Some((d, *id));
}
}
if let Some((_, id)) = best {
return Some(Sel::Track(id));
}
}
None
}
fn map_click(&mut self, ui: &mut MapUi, at: (f32, f32)) {
// Markers merged into one: a click goes in on them.
if let Some(cl) = ui.clusters.iter().find(|c| (c.c.0 - at.0).hypot(c.c.1 - at.1) <= 11.0) {
let (x, z) = ui.to_world(cl.c);
ui.centre = (x, z);
ui.scale = (ui.scale * 3.0).clamp(SCALE_MIN, SCALE_MAX);
ui.follow = false;
return;
}
let hit = self.pick_at(ui, at);
match ui.mode {
Mode::Guard(id) => {
if let Some(Sel::Object(k)) = hit
&& let Some(i) = self.sim.sams.iter().position(|s| s.id == id)
{
let g = self.sim.targets[k];
self.edit_doctrine(i, |d| match d.guards.iter().position(|x| x.distance(g) < 16.0) {
Some(j) => {
d.guards.remove(j);
}
None => d.guards.push(g),
});
} else if hit.is_none() {
ui.mode = Mode::View;
}
}
Mode::Sector(id, centre) => {
let Some(i) = self.sim.sams.iter().position(|s| s.id == id) else {
ui.mode = Mode::View;
return;
};
let (x, z) = ui.to_world(at);
let a = sim::heading_of(DVec3::new(x - self.sim.sams[i].pos.x, 0.0, z - self.sim.sams[i].pos.z));
match centre {
None => ui.mode = Mode::Sector(id, Some(a)),
Some(c) => {
let half = sim_angle_diff(c, a).abs().clamp(10f64.to_radians(), std::f64::consts::PI);
self.edit_doctrine(i, |d| d.sector = Some((c, half)));
ui.mode = Mode::View;
}
}
}
_ => {
ui.sel = hit;
ui.follow = false;
}
}
}
/// Right button in the view: a mobile system selected drives to the point.
fn map_right(&mut self, ui: &mut MapUi, at: (f32, f32)) {
if let Some(i) = self.sel_sam(ui)
&& self.sim.sams[i].kind.mobile()
{
let (x, z) = ui.to_world(at);
match self.ground_y(x, z) {
Some(y) => {
if self.sim.order_move(i, DVec3::new(x, y, z)) {
let s = &self.sim.sams[i];
ui.note(self.sim.tick, format!("{} №{}: на марш, {}", s.kind.name(), i + 1, distance(s.pos.distance(DVec3::new(x, y, z)))));
}
}
None => ui.note(self.sim.tick, "Земля там не загружена: подождите и повторите"),
}
} else {
ui.sel = None;
ui.mode = Mode::View;
}
}
// ------------------------------------------------------------------ the editor
fn draft_pick(&self, ui: &MapUi, at: (f32, f32)) -> Option<EdSel> {
let near = |w: DVec3| {
let s = ui.to_screen(w.x, w.z);
(s.0 - at.0).hypot(s.1 - at.1) <= PICK_R
};
if let Some(i) = ui.draft.sams.iter().position(|s| !s.gone && near(s.pos)) {
return Some(EdSel::Sam(i));
}
ui.draft.objs.iter().position(|o| !o.gone && near(o.pos)).map(EdSel::Obj)
}
fn editor_press(&mut self, ui: &mut MapUi, at: (f32, f32)) {
self.ensure_draft(ui);
if let Some(hit) = self.draft_pick(ui, at) {
ui.push_history();
ui.ed_sel = Some(hit);
ui.drag = Some(match hit {
EdSel::Sam(i) => Drag::Sam(i),
EdSel::Obj(i) => Drag::Obj(i),
});
return;
}
let (x, z) = ui.to_world(at);
match ui.pick {
Pick::None => {
ui.ed_sel = None;
ui.drag = Some(Drag::Pan { from: at, centre: ui.centre, moved: false });
}
p => {
let Some(y) = self.ground_y(x, z) else {
ui.note(self.sim.tick, "Земля здесь не загружена: подождите секунду и нажмите снова");
return;
};
ui.push_history();
let pos = DVec3::new(x, y, z);
match p {
Pick::Sam(kind) => {
ui.draft.sams.push(DSam { id: None, kind, pos, heading: ui.heading, gone: false });
ui.ed_sel = Some(EdSel::Sam(ui.draft.sams.len() - 1));
}
Pick::Object => {
ui.draft.objs.push(DObj { idx: None, pos, gone: false });
ui.ed_sel = Some(EdSel::Obj(ui.draft.objs.len() - 1));
}
Pick::None => {}
}
}
}
}
fn editor_remove_at(&mut self, ui: &mut MapUi, at: (f32, f32)) {
if let Some(hit) = self.draft_pick(ui, at) {
ui.push_history();
match hit {
EdSel::Sam(i) => remove_dsam(&mut ui.draft, i),
EdSel::Obj(i) => remove_dobj(&mut ui.draft, i),
}
ui.ed_sel = None;
} else {
ui.pick = Pick::None;
}
}
/// Builds what the draft says: nothing before this, and nothing is spent until it.
fn commit_draft(&mut self, ui: &mut MapUi) {
let tick = self.sim.tick;
if !self.draft_changed(ui) {
ui.mode = Mode::View;
ui.draft = Draft::default();
return;
}
if self.battle() {
ui.note(tick, "Бой идёт: расстановка закрыта");
return;
}
let d = std::mem::take(&mut ui.draft);
// Objects: removals from the end so the indices hold.
let mut gone: Vec<usize> = d.objs.iter().filter(|o| o.gone).filter_map(|o| o.idx).collect();
gone.sort_unstable_by(|a, b| b.cmp(a));
for o in &d.objs {
if let (Some(i), false) = (o.idx, o.gone)
&& let Some(t) = self.sim.targets.get_mut(i)
{
*t = o.pos;
}
}
for i in gone {
if i < self.sim.targets.len() {
self.sim.targets.remove(i);
if i < self.sim.target_health.len() {
self.sim.target_health.remove(i);
}
}
}
for o in d.objs.iter().filter(|o| o.idx.is_none() && !o.gone) {
self.sim.targets.push(o.pos);
self.sim.target_health.push(100.0);
}
for s in &d.sams {
match (s.id, s.gone) {
(Some(id), true) => self.sim.sams.retain(|x| x.id != id),
(Some(id), false) => {
if let Some(i) = self.sim.sams.iter().position(|x| x.id == id) {
let moved = self.sim.sams[i].pos.distance(s.pos) > 0.01;
let sam = &mut self.sim.sams[i];
sam.heading = s.heading;
if moved {
// Before the battle a unit is simply put down elsewhere.
sam.pos = s.pos;
sam.dest = None;
}
}
}
(None, false) => {
let id = self.sim.id();
let mut sam = Sam::new(id, s.kind, s.pos, s.heading);
if let Some(r) = self.sim.roles.get(&s.kind) {
sam.roles = *r;
}
self.sim.sams.push(sam);
}
(None, true) => {}
}
}
self.dirty = true;
ui.mode = Mode::View;
ui.history.clear();
ui.pick = Pick::None;
ui.ed_sel = None;
ui.sel = None;
ui.note(tick, "Расстановка подтверждена");
}
// ------------------------------------------------------------------ drawing
fn map_shapes(&mut self, ui: &mut MapUi) -> Vec<Shape> {
ui.buttons.clear();
ui.clusters.clear();
ui.blocked.clear();
let (w, h) = ui.size;
ui.u = (h / 300.0).clamp(1.0, 1.4);
let now = self.sim.tick;
let editing = ui.mode == Mode::Editor;
let cur_world = ui.to_world(ui.cursor);
// The ground under the pointer is asked for while placing, so that the click finds it.
if editing || ui.pick != Pick::None {
let _ = self.ground_y(cur_world.0, cur_world.1);
}
// Chunks round the view's middle are loaded now and then, so a place looked at fills in.
if now >= ui.chunks_at + 10 && ui.scale >= 0.2 {
ui.chunks_at = now;
let (cx, cz) = ((ui.centre.0.floor() as i32) >> 4, (ui.centre.1.floor() as i32) >> 4);
let wanted: Vec<(i32, i32)> = (-2..2).flat_map(|dz| (-2..2).map(move |dx| (cx + dx, cz + dz))).collect();
render::load_chunks(&wanted);
}
let draft = ui.draft.clone();
// The panels first: the labels keep clear of them. They are drawn last, over the picture.
let mut panels: Vec<Shape> = Vec::with_capacity(400);
self.map_panels(ui, &mut panels, &draft);
let mut s: Vec<Shape> = Vec::with_capacity(2048);
let mut labs: Vec<Lab> = Vec::new();
let mut taken: Vec<[f32; 4]> = ui.blocked.clone();
// Terrain.
if ui.filters[F_TERRAIN] {
self.map_terrain(ui, &mut s);
}
self.map_grid(ui, &mut s);
// What covers what.
let armed: Vec<(SamKind, DVec3)> = if editing {
draft.sams.iter().filter(|d| !d.gone && d.kind.range() > 0.0).map(|d| (d.kind, d.pos)).collect()
} else {
self.sim.sams.iter().filter(|x| x.alive() && x.kind.range() > 0.0).map(|x| (x.kind, x.pos)).collect()
};
if editing || ui.filters[F_TINT] {
self.map_tint(ui, &mut s, &draft, &armed);
}
let picked = if editing { match ui.ed_sel { Some(EdSel::Sam(i)) => draft.sams.get(i).map(|d| d.pos), _ => None } } else { self.sel_pos(ui) };
// Reach rings of the weapons.
if ui.filters[F_RINGS] {
let list: Vec<(SamKind, DVec3, bool)> = if editing {
draft.sams.iter().filter(|d| !d.gone).map(|d| (d.kind, d.pos, d.id.is_none())).collect()
} else {
self.sim.sams.iter().filter(|x| x.alive()).map(|x| (x.kind, x.pos, false)).collect()
};
let many = list.len() > 12;
for (kind, pos, ghost) in list {
let r = kind.range();
let chosen = picked.is_some_and(|p| p.distance(pos) < 1.0);
if r > 0.0 && ui.sclass[sys_class(kind)] && (!many || chosen || ghost) {
let c = ui.to_screen(pos.x, pos.z);
ring(ui, &mut s, c, (r * ui.scale) as f32, 1.0, alpha(if ghost { 0xFFE070 } else { 0x40A0FF }, 0.75));
}
}
}
// The radars' coverage edges: what a low flyer is seen at, the land taken into account.
if ui.filters[F_VIEW] {
self.map_rims(ui, &mut s, &draft, picked);
}
// The selected system's sensor, sector and guards.
if let Some(i) = self.sel_sam(ui) {
let sam = &self.sim.sams[i];
let c = ui.to_screen(sam.pos.x, sam.pos.z);
let sens = sam.kind.spec().sensor;
if sens > 0.0 && !ui.filters[F_VIEW] {
ring(ui, &mut s, c, (sens * ui.scale) as f32, 1.0, alpha(0x80FF90, 0.45));
}
self.map_sector(ui, &mut s, sam.pos, &sam.doctrine, sam.kind.range().max(200.0));
for g in &sam.doctrine.guards {
let gp = ui.to_screen(g.x, g.z);
s.push(line(c, gp, 1.0, alpha(0xFFE070, 0.7)));
ring(ui, &mut s, gp, (sim::doctrine::GUARD_R * ui.scale) as f32, 1.0, alpha(0xFFE070, 0.6));
}
}
if let Mode::Sector(id, centre) = ui.mode
&& let Some(sam) = self.sim.sams.iter().find(|x| x.id == id)
{
let a = sim::heading_of(DVec3::new(cur_world.0 - sam.pos.x, 0.0, cur_world.1 - sam.pos.z));
let d = match centre {
None => Doctrine { sector: Some((a, 15f64.to_radians())), ..Default::default() },
Some(c) => Doctrine { sector: Some((c, sim_angle_diff(c, a).abs().clamp(10f64.to_radians(), std::f64::consts::PI))), ..Default::default() },
};
self.map_sector(ui, &mut s, sam.pos, &d, sam.kind.range().max(200.0));
}
// Flights of the strike missiles: the line to the target, the marker where the missile really is (#106).
for f in &self.sim.strikes.flights {
let a = ui.to_screen(f.from.x, f.from.z);
let b = ui.to_screen(f.aim.x, f.aim.y);
s.push(line(a, b, 1.0, alpha(0xFFA040, 0.5)));
let c = ui.to_screen(f.pos.x, f.pos.z);
s.push(diamond(c.0, c.1, 3.0, ORANGE));
}
// Objects.
if ui.filters[F_OBJECTS] {
self.map_objects(ui, &mut s, &draft, &armed, &mut labs, &mut taken);
}
// Systems.
if ui.filters[F_SAMS] {
self.map_sams(ui, &mut s, &draft, &mut labs, &mut taken);
}
// Launch sites the radars found.
if ui.filters[F_SITES] {
self.map_sites(ui, &mut s, &mut labs, &mut taken);
}
// Own interceptors.
for m in &self.sim.missiles {
let c = ui.to_screen(m.pos.x, m.pos.z);
if ui.on_screen(c, 4.0) {
s.push(fill(c.0 - 1.0, c.1 - 1.0, 2.0, 2.0, YELLOW));
}
}
// The network's tracks.
if ui.filters[F_TRACKS] || ui.filters[F_TRAILS] {
self.map_tracks(ui, &mut s, &mut labs, &mut taken);
}
// The truth, when the sandbox shows it, marked as such.
if self.sim.truth {
for d in &self.sim.drones {
let c = ui.to_screen(d.pos.x, d.pos.z);
if ui.on_screen(c, 4.0) {
s.extend(frame(c.0 - 3.0, c.1 - 3.0, 6.0, 6.0, 1.0, alpha(0xFF4040, 0.9)));
}
}
}
// The ghost under the pointer while placing.
if editing && let Some(y) = self.ground_y(cur_world.0, cur_world.1) {
let c = ui.cursor;
match ui.pick {
Pick::Sam(kind) => {
s.push(fill(c.0 - 4.0, c.1 - 4.0, 8.0, 8.0, alpha(0xFFE070, 0.6)));
let (dx, dz) = dir_of(ui.heading);
s.push(line(c, (c.0 + dx as f32 * 11.0, c.1 + dz as f32 * 11.0), 1.5, alpha(0xFFE070, 0.6)));
if kind.range() > 0.0 {
ring(ui, &mut s, c, (kind.range() * ui.scale) as f32, 1.0, alpha(0xFFE070, 0.55));
}
let _ = y;
}
Pick::Object => s.push(fill(c.0 - 4.0, c.1 - 4.0, 8.0, 8.0, alpha(0xFFE070, 0.6))),
Pick::None => {}
}
} else if editing && ui.pick != Pick::None {
s.push(text("земля не загружена", ui.cursor.0 + 8.0, ui.cursor.1 + 8.0, RED));
}
place_labels((w, h), labs, taken, &mut s);
// The picture is cut, never the panels over it.
s.truncate(8000 - panels.len().min(900));
s.extend(panels);
s
}
/// The objects: merged where they crowd, the number beside each.
fn map_objects(&self, ui: &mut MapUi, s: &mut Vec<Shape>, draft: &Draft, armed: &[(SamKind, DVec3)], labs: &mut Vec<Lab>, taken: &mut Vec<[f32; 4]>) {
let editing = ui.mode == Mode::Editor;
let list: Vec<(usize, DVec3, bool)> = if editing {
draft.objs.iter().enumerate().filter(|(_, o)| !o.gone).map(|(i, o)| (i, o.pos, o.idx.is_none())).collect()
} else {
self.sim.targets.iter().enumerate().map(|(i, p)| (i, *p, false)).collect()
};
let vis: Vec<(usize, DVec3, bool, (f32, f32))> = list
.into_iter()
.map(|(i, p, g)| (i, p, g, ui.to_screen(p.x, p.z)))
.filter(|v| ui.on_screen(v.3, 20.0))
.collect();
let pos: Vec<(f32, f32)> = vis.iter().map(|v| v.3).collect();
let solo: Vec<bool> = vis.iter().map(|v| ui.sel == Some(Sel::Object(v.0)) || ui.ed_sel == Some(EdSel::Obj(v.0)) && editing).collect();
let covered = |p: DVec3| armed.iter().any(|(k, pos)| reaches(*k, *pos, p));
for grp in groups_of(&pos, &solo, CLUSTER_R, !editing) {
if grp.len() > 1 {
let bare = grp.iter().any(|&k| !covered(vis[k].1));
let col = if bare && !armed.is_empty() { RED } else { WHITE };
let members: Vec<(f32, f32)> = grp.iter().map(|&k| vis[k].3).collect();
draw_cluster(ui, s, taken, &members, col);
continue;
}
let (i, p, ghost, c) = vis[grp[0]];
let cov = covered(p);
let col = if !cov && (editing || !armed.is_empty()) { RED } else if ghost { YELLOW } else { WHITE };
s.push(fill(c.0 - 4.0, c.1 - 4.0, 8.0, 8.0, col));
s.push(fill(c.0 - 2.5, c.1 - 2.5, 5.0, 5.0, 0xFF101010));
taken.push([c.0 - 5.0, c.1 - 5.0, 10.0, 10.0]);
let chosen = ui.sel == Some(Sel::Object(i)) && !editing;
if !editing {
let hp = self.sim.target_health.get(i).copied().unwrap_or(100.0);
add_lab(ui, labs, format!("{}{}", i + 1, if hp < 100.0 { format!(" {hp:.0}%") } else { String::new() }), c, 6.0, col, chosen);
} else if !cov {
add_lab(ui, labs, "не прикрыт".into(), c, 6.0, RED, false);
}
if chosen {
s.extend(frame(c.0 - 8.0, c.1 - 8.0, 16.0, 16.0, 1.0, GREEN));
}
}
}
/// The systems: merged where they crowd, with short names; the filter by class applies.
fn map_sams(&self, ui: &mut MapUi, s: &mut Vec<Shape>, draft: &Draft, labs: &mut Vec<Lab>, taken: &mut Vec<[f32; 4]>) {
let editing = ui.mode == Mode::Editor;
// (id, kind, position, heading, ghost, alive, place in the draft, number)
let list: Vec<(Option<u32>, SamKind, DVec3, f64, bool, bool, usize, usize)> = if editing {
draft.sams.iter().enumerate().filter(|(_, d)| !d.gone).map(|(i, d)| (d.id, d.kind, d.pos, d.heading, d.id.is_none(), true, i, i + 1)).collect()
} else {
self.sim.sams.iter().enumerate().map(|(i, x)| (Some(x.id), x.kind, x.pos, x.heading, false, x.alive(), 0, i + 1)).collect()
};
let vis: Vec<_> = list
.into_iter()
.filter(|v| editing || ui.sclass[sys_class(v.1)] || ui.sel == v.0.map(Sel::Sam))
.map(|v| (v, ui.to_screen(v.2.x, v.2.z)))
.filter(|v| ui.on_screen(v.1, 30.0))
.collect();
let pos: Vec<(f32, f32)> = vis.iter().map(|v| v.1).collect();
let solo: Vec<bool> = vis
.iter()
.map(|(v, _)| !editing && v.0.is_some() && ui.sel == v.0.map(Sel::Sam) || editing && ui.ed_sel == Some(EdSel::Sam(v.6)))
.collect();
for grp in groups_of(&pos, &solo, CLUSTER_R, !editing) {
if grp.len() > 1 {
let members: Vec<(f32, f32)> = grp.iter().map(|&k| vis[k].1).collect();
let col = if grp.iter().any(|&k| vis[k].0.1.armed()) { 0xFF40A0FF } else { 0xFF60D0A0 };
draw_cluster(ui, s, taken, &members, col);
continue;
}
let ((id, kind, _, heading, ghost, alive, di, n), c) = vis[grp[0]];
let col = if !alive {
0xFF704040
} else if ghost {
YELLOW
} else if kind.range() > 0.0 {
0xFF40A0FF
} else {
0xFF60D0A0
};
s.push(fill(c.0 - 4.0, c.1 - 4.0, 8.0, 8.0, col));
let (dx, dz) = dir_of(heading);
s.push(line(c, (c.0 + dx as f32 * 11.0, c.1 + dz as f32 * 11.0), 1.5, col));
taken.push([c.0 - 5.0, c.1 - 5.0, 10.0, 10.0]);
let chosen = !editing && id.is_some() && ui.sel == id.map(Sel::Sam);
let ed = editing && ui.ed_sel == Some(EdSel::Sam(di));
let name = if chosen || ed || ui.scale > 1.5 { format!("{} {n}", short_name(kind)) } else { short_name(kind).to_string() };
add_lab(ui, labs, name, c, 7.0, alpha(col, 0.95), chosen || ed);
if chosen || ed {
s.extend(frame(c.0 - 8.0, c.1 - 8.0, 16.0, 16.0, 1.0, GREEN));
}
}
}
/// The radars' coverage edges. A radar's edge is where the land first hides a low flyer along each ray round it;
/// each is worked out from the sim's own horizon (`low_rim`), a few a redraw, and kept a while. The selected
/// one shows its dead zones filled.
fn map_rims(&self, ui: &mut MapUi, s: &mut Vec<Shape>, draft: &Draft, picked: Option<DVec3>) {
let editing = ui.mode == Mode::Editor;
let now = self.sim.tick;
// (the unit it is, kind, radar)
let list: Vec<(Option<u32>, SamKind, LowSensor, DVec3)> = if editing {
draft
.sams
.iter()
.filter(|d| !d.gone)
.filter_map(|d| {
// A unit that stays where it is keeps its horizon; a new or moved one has none yet.
let live = d.id.filter(|&id| self.sim.sams.iter().any(|x| x.id == id && x.pos.distance(d.pos) < 0.01));
self.sim.low_sensor(d.kind, d.pos, live).map(|ls| (live, d.kind, ls, d.pos))
})
.collect()
} else {
self.sim.sams.iter().filter(|x| x.radar_up()).filter_map(|x| self.sim.low_sensor(x.kind, x.pos, Some(x.id)).map(|ls| (Some(x.id), x.kind, ls, x.pos))).collect()
};
let list: Vec<_> = list.into_iter().filter(|v| ui.sclass[sys_class(v.1)] || picked.is_some_and(|p| p.distance(v.3) < 1.0)).collect();
let (w, h) = ui.size;
let mid = (w / 2.0, h / 2.0);
let reach_px = mid.0.hypot(mid.1);
// Whether the circle comes near the screen at all.
let near_view = |ui: &MapUi, pos: DVec3, reach: f64| {
let c = ui.to_screen(pos.x, pos.z);
let r = (reach * ui.scale) as f32;
let far = (c.0 - mid.0).hypot(c.1 - mid.1);
r >= 3.0 && far - r <= reach_px && r - far <= reach_px
};
// Work out the oldest few that are on the screen.
let mut stale: Vec<(u64, usize)> = Vec::new();
for (i, (id, _, ls, pos)) in list.iter().enumerate() {
let Some(id) = id else { continue };
if !near_view(ui, *pos, ls.reach) {
continue;
}
match ui.rims.get(id) {
Some(c) if c.pos == *pos && (c.reach - ls.reach).abs() < 0.5 && c.terrain == ls.terrain && now.saturating_sub(c.tick) < RIM_REFRESH => {}
Some(c) => stale.push((now.saturating_sub(c.tick) + if c.pos == *pos { 0 } else { 100_000 }, i)),
None => stale.push((u64::MAX, i)),
}
}
stale.sort_by(|a, b| b.0.cmp(&a.0));
for (_, i) in stale.into_iter().take(RIMS_PER_FRAME) {
let (id, _, ls, pos) = &list[i];
let d = self.sim.low_rim(&self.ground, ls);
ui.rims.insert(id.unwrap_or(u32::MAX), Rim { tick: now, pos: *pos, reach: ls.reach, terrain: ls.terrain, d });
}
if ui.rims.len() > list.len() + 64 {
let live: std::collections::HashSet<u32> = self.sim.sams.iter().map(|x| x.id).collect();
ui.rims.retain(|id, _| live.contains(id));
}
// Draw.
let many = list.len() > 16;
let mut dashes = 0usize;
for (id, kind, ls, pos) in &list {
if !near_view(ui, *pos, ls.reach) {
continue;
}
let chosen = picked.is_some_and(|p| p.distance(*pos) < 1.0);
// A crowd of systems: only the selected one and the long-range radars show their edge.
if many && !chosen && sys_class(*kind) != 2 {
continue;
}
let cached = id.and_then(|i| ui.rims.get(&i)).filter(|c| c.pos == *pos && (c.reach - ls.reach).abs() < 0.5);
let full;
let d: &[f32] = match cached {
Some(c) => &c.d,
None => {
full = vec![ls.reach as f32; sim::RIM_RAYS];
&full
}
};
let base = match sys_class(*kind) {
2 => 0x80FF90,
1 => 0xFFC060,
_ => 0x60B0FF,
};
let col = alpha(base, if chosen { 0.95 } else if many { 0.35 } else { 0.55 });
let o = ui.to_screen(pos.x, pos.z);
let n = sim::RIM_RAYS;
let sub = if chosen || (!many && ls.reach * ui.scale > 160.0) { 2 } else { 1 };
let at = |k: f32| {
// Ray k (fractional): the distance between the two rays it lies between.
let i = k.floor() as usize % n;
let j = (i + 1) % n;
let f = k - k.floor();
let dist = (d[i] + (d[j] - d[i]) * f) as f64 * ui.scale;
let a = k as f64 / n as f64 * std::f64::consts::TAU;
(o.0 + (a.sin() * dist) as f32, o.1 + (a.cos() * dist) as f32)
};
// A dead zone: the part of the circle the land takes away, filled, for the one in hand.
if chosen {
for i in 0..n {
let (j, r0, r1) = ((i + 1) % n, d[i], d[(i + 1) % n]);
let full_r = ls.reach as f32;
if r0 >= full_r - 1.0 && r1 >= full_r - 1.0 {
continue;
}
let edge = |k: usize, r: f32| {
let a = k as f64 / n as f64 * std::f64::consts::TAU;
(o.0 + (a.sin() * r as f64 * ui.scale) as f32, o.1 + (a.cos() * r as f64 * ui.scale) as f32)
};
let (a0, a1, b0, b1) = (edge(i, r0), edge(i, full_r), edge(j, full_r), edge(j, r1));
if ui.on_screen(a1, 80.0) || ui.on_screen(b1, 80.0) || ui.on_screen(a0, 80.0) {
s.push(Shape::Quad(QuadShape { corners: (pt(a0.0, a0.1), pt(a1.0, a1.1), pt(b0.0, b0.1), pt(b1.0, b1.1)), color: alpha(0xFF4040, 0.2) }));
}
}
}
for step in (0..n * sub).step_by(2) {
if dashes >= RIM_DASHES {
break;
}
let (k0, k1) = (step as f32 / sub as f32, (step + 1) as f32 / sub as f32);
let (p0, p1) = (at(k0), at(k1));
if ui.on_screen(p0, 30.0) || ui.on_screen(p1, 30.0) {
s.push(line(p0, p1, if chosen { 1.5 } else { 1.0 }, col));
dashes += 1;
}
}
}
}
/// The coverage tint: a cell is green where a weapon reaches and a radar sees a low flyer over the land, amber where a
/// weapon reaches but no radar sees (the land hides it), blue where a radar sees and no weapon reaches. Kept while the
/// view and the layout stay the same.
fn map_tint(&self, ui: &mut MapUi, s: &mut Vec<Shape>, draft: &Draft, armed: &[(SamKind, DVec3)]) {
let editing = ui.mode == Mode::Editor;
let (w, h) = ui.size;
let sensors: Vec<LowSensor> = if editing {
draft
.sams
.iter()
.filter(|d| !d.gone)
.filter_map(|d| {
let live = d.id.filter(|&id| self.sim.sams.iter().any(|x| x.id == id && x.pos.distance(d.pos) < 0.01));
self.sim.low_sensor(d.kind, d.pos, live)
})
.collect()
} else {
self.sim.low_sensors()
};
let mut key = 0xcbf29ce484222325u64;
for v in [ui.centre.0.round().to_bits(), ui.centre.1.round().to_bits(), ui.scale.to_bits(), w.to_bits() as u64, h.to_bits() as u64, self.sim.tick / 20, editing as u64, armed.len() as u64, sensors.len() as u64] {
key = (key ^ v).wrapping_mul(0x100000001b3);
}
for (_, p) in armed {
key = (key ^ p.x.to_bits() ^ p.z.to_bits().rotate_left(21)).wrapping_mul(0x100000001b3);
}
for ls in &sensors {
key = (key ^ ls.ant.x.to_bits() ^ ls.ant.z.to_bits().rotate_left(21) ^ ls.terrain as u64).wrapping_mul(0x100000001b3);
}
if ui.tint.key != key {
let cell = ((w * h / TINT_CELLS).sqrt()).max(14.0);
let tl = ui.to_world((0.0, 0.0));
let br = ui.to_world((w, h));
let near = |x: f64, z: f64, r: f64| x + r >= tl.0 && x - r <= br.0 && z + r >= tl.1 && z - r <= br.1;
let weap: Vec<(f64, f64, f64)> = armed.iter().filter(|(k, p)| near(p.x, p.z, k.range())).map(|(k, p)| (p.x, p.z, k.range() * k.range())).collect();
let sens: Vec<&LowSensor> = sensors.iter().filter(|l| near(l.ant.x, l.ant.z, l.reach)).collect();
let mut runs: Vec<([f32; 4], u32)> = Vec::new();
let mut asks = 0usize;
let mut y = 0.0f32;
while y < h {
let mut x = 0.0f32;
let mut cur: Option<([f32; 4], u32)> = None;
while x < w {
let c = ui.to_world((x + cell / 2.0, y + cell / 2.0));
let a = weap.iter().any(|(wx, wz, r2)| (wx - c.0).powi(2) + (wz - c.1).powi(2) <= *r2);
let mut b = false;
for l in &sens {
if (l.ant.x - c.0).powi(2) + (l.ant.z - c.1).powi(2) > l.reach * l.reach {
continue;
}
asks += 1;
if asks > TINT_ASKS {
break;
}
if self.sim.low_sees(&self.ground, l, c.0, c.1) {
b = true;
break;
}
}
let col = match (a, b) {
(true, true) => Some(alpha(0x40FF60, 0.12)),
(true, false) => Some(alpha(0xFFB030, 0.24)),
(false, true) => Some(alpha(0x4090FF, 0.07)),
_ => None,
};
match (col, &mut cur) {
(Some(c), Some((r, rc))) if *rc == c => r[2] += cell,
(col, cur_run) => {
if let Some(done) = cur_run.take() {
runs.push(done);
}
if let Some(c) = col {
*cur_run = Some(([x, y, cell, cell], c));
}
}
}
x += cell;
}
if let Some(done) = cur {
runs.push(done);
}
y += cell;
}
ui.tint = Tint { key, runs };
}
for (r, c) in &ui.tint.runs {
s.push(fill(r[0], r[1], r[2], r[3], *c));
}
}
fn map_terrain(&mut self, ui: &MapUi, s: &mut Vec<Shape>) {
let (w, h) = ui.size;
let tl = ui.to_world((0.0, 0.0));
let br = ui.to_world((w, h));
let mut bpt = 1u32;
loop {
let span = 128.0 * bpt as f64;
let nx = ((br.0 - tl.0) / span).ceil() as i64 + 1;
let nz = ((br.1 - tl.1) / span).ceil() as i64 + 1;
if (nx * nz <= 20 && 128.0 * bpt as f64 * ui.scale >= 64.0) || bpt >= 64 {
break;
}
bpt *= 2;
}
let span = 128 * bpt as i32;
let (x0, z0) = ((tl.0.floor() as i32).div_euclid(span) * span, (tl.1.floor() as i32).div_euclid(span) * span);
let px = (span as f64 * ui.scale) as f32;
let mut z = z0;
let mut n = 0;
while (z as f64) < br.1 && n < 24 {
let mut x = x0;
while (x as f64) < br.0 && n < 24 {
let a = ui.to_screen(x as f64, z as f64);
s.push(Shape::Terrain(TerrainShape { rect: Rect { x: a.0, y: a.1, w: px, h: px }, x, z, blocks_per_texel: bpt }));
n += 1;
x += span;
}
z += span;
}
}
fn map_grid(&self, ui: &MapUi, s: &mut Vec<Shape>) {
let (w, h) = ui.size;
// A square of 1, 2, 5... x 10^n blocks that is at least 70 pixels wide.
let mut step = 10.0f64;
for m in [1.0, 2.0, 5.0].iter().cycle().zip(0..30).map(|(m, i)| m * 10f64.powi(1 + i / 3)) {
step = m;
if m * ui.scale >= 70.0 {
break;
}
}
let tl = ui.to_world((0.0, 0.0));
let br = ui.to_world((w, h));
let mut x = (tl.0 / step).floor() * step;
while x < br.0 {
let sx = ui.to_screen(x, 0.0).0;
s.push(fill(sx, 0.0, 1.0, h, 0x18FFFFFF));
x += step;
}
let mut z = (tl.1 / step).floor() * step;
while z < br.1 {
let sy = ui.to_screen(0.0, z).1;
s.push(fill(0.0, sy, w, 1.0, 0x18FFFFFF));
z += step;
}
// The scale bar.
let bar = (step * ui.scale) as f32;
s.push(fill(12.0, h - 16.0, bar, 2.0, WHITE));
s.push(fill(12.0, h - 20.0, 1.0, 6.0, WHITE));
s.push(fill(12.0 + bar, h - 20.0, 1.0, 6.0, WHITE));
s.push(text(distance(step), 14.0, h - 30.0, WHITE));
}
fn map_sector(&self, ui: &MapUi, s: &mut Vec<Shape>, pos: DVec3, d: &Doctrine, reach: f64) {
let Some((c, half)) = d.sector else { return };
let o = ui.to_screen(pos.x, pos.z);
let r = (reach * ui.scale) as f32;
let n = ((half * 2.0 / 0.15) as usize).clamp(4, 48);
let at = |a: f64| {
let (dx, dz) = dir_of(a);
(o.0 + dx as f32 * r, o.1 + dz as f32 * r)
};
let col = alpha(0xFFB040, 0.16);
for i in 0..n {
let a0 = c - half + half * 2.0 * i as f64 / n as f64;
let a1 = c - half + half * 2.0 * (i + 1) as f64 / n as f64;
s.push(Shape::Quad(QuadShape { corners: (pt(o.0, o.1), pt(at(a0).0, at(a0).1), pt(at(a1).0, at(a1).1), pt(o.0, o.1)), color: col }));
}
s.push(line(o, at(c - half), 1.0, alpha(0xFFB040, 0.8)));
s.push(line(o, at(c + half), 1.0, alpha(0xFFB040, 0.8)));
}
fn map_sites(&self, ui: &mut MapUi, s: &mut Vec<Shape>, labs: &mut Vec<Lab>, taken: &mut Vec<[f32; 4]>) {
let (w, h) = ui.size;
for k in &self.sim.strikes.known {
let Some(e) = k.est else { continue };
let gone = matches!(k.state, SiteState::Destroyed(_));
let col = if gone { 0xFF707070 } else { ORANGE };
let chosen = ui.sel == Some(Sel::Site(k.site));
if e.fix {
let c = ui.to_screen(e.pos.x, e.pos.y);
// The circle of error: the place is somewhere in it.
ring(ui, s, c, (e.radius * ui.scale) as f32, 1.0, alpha(col & 0xFFFFFF, 0.8));
if ui.on_screen(c, 20.0) {
s.push(diamond(c.0, c.1, 5.0, col));
s.push(diamond(c.0, c.1, 2.5, 0xFF101010));
taken.push([c.0 - 6.0, c.1 - 6.0, 12.0, 12.0]);
add_lab(ui, labs, format!("ПУ {}{}", k.site, if gone { " ×" } else { "" }), c, 7.0, col, chosen);
if chosen {
s.extend(frame(c.0 - 9.0, c.1 - 9.0, 18.0, 18.0, 1.0, GREEN));
}
}
} else {
// Only a bearing: a ray from where it was seen.
let o = ui.to_screen(e.origin.x, e.origin.y);
let (dx, dz) = (e.bearing.sin(), -e.bearing.cos());
let len = (w.max(h) * 2.0) as f64;
let b = (o.0 + (dx * len) as f32, o.1 + (dz * len) as f32);
s.push(line(o, b, 1.0, alpha(0xFFA040, 0.35)));
// The ray's label near the origin when that is on the screen, else clamped to the rim.
let at = ((o.0 + dx as f32 * 40.0).clamp(30.0, w - 30.0), (o.1 + dz as f32 * 40.0).clamp(10.0, h - 10.0));
add_lab(ui, labs, format!("ПУ {}: {:.0}°", k.site, e.bearing.to_degrees()), at, 0.0, alpha(0xFFA040, 0.9), chosen);
}
}
}
fn map_tracks(&self, ui: &mut MapUi, s: &mut Vec<Shape>, labs: &mut Vec<Lab>, taken: &mut Vec<[f32; 4]>) {
let now = self.sim.tick;
let pic = self.sim.picture();
// Only the classes asked for (the selected one always).
let shown: Vec<(&u32, &Track)> = pic.iter().filter(|(id, t)| ui.tclass[tgt_class(t)] || ui.sel == Some(Sel::Track(**id))).collect();
for (id, t) in &shown {
let chosen = ui.sel == Some(Sel::Track(**id));
if ui.filters[F_TRAILS]
&& let Some(trail) = ui.trails.get(*id)
{
let col = alpha(0xFF6060, if chosen { 0.95 } else { 0.5 });
let mut prev: Option<(f32, f32)> = None;
for p in trail {
let c = ui.to_screen(p.0 as f64, p.1 as f64);
if let Some(a) = prev
&& (ui.on_screen(a, 0.0) || ui.on_screen(c, 0.0))
{
s.push(line(a, c, 1.0, col));
}
prev = Some(c);
}
}
if !ui.filters[F_TRACKS] {
continue;
}
let forecast = t.forecast(now);
let e = t.est(now);
let c = ui.to_screen(e.x, e.z);
let m = ui.to_screen(t.pos.x, t.pos.z);
// The last measurement and the forecast from it: dashes, never drawn as a certainty.
if forecast {
s.push(line(m, c, 1.0, alpha(0xFFB0B0, 0.4)));
let r = (t.uncertainty(now) * ui.scale) as f32;
ring(ui, s, c, r.min(300.0), 1.0, alpha(0xFFB0B0, 0.5));
}
if chosen {
// Ahead along the course for 30 s, dashed.
let v = t.vel;
let ahead = ui.to_screen(e.x + v.x * 600.0, e.z + v.z * 600.0);
dashed(s, c, ahead, alpha(0xFF8080, 0.8));
}
}
if !ui.filters[F_TRACKS] {
return;
}
let vis: Vec<(u32, &Track, (f32, f32))> = shown
.iter()
.map(|(id, t)| {
let e = t.est(now);
(**id, *t, ui.to_screen(e.x, e.z))
})
.filter(|v| ui.on_screen(v.2, 12.0))
.collect();
let pos: Vec<(f32, f32)> = vis.iter().map(|v| v.2).collect();
let solo: Vec<bool> = vis.iter().map(|v| ui.sel == Some(Sel::Track(v.0))).collect();
for grp in groups_of(&pos, &solo, CLUSTER_R * 0.8, true) {
if grp.len() > 1 {
let members: Vec<(f32, f32)> = grp.iter().map(|&k| vis[k].2).collect();
draw_cluster(ui, s, taken, &members, RED);
continue;
}
let (id, t, c) = vis[grp[0]];
let chosen = ui.sel == Some(Sel::Track(id));
let forecast = t.forecast(now);
let age = t.age(now);
let col = if forecast { alpha(0xFFB0B0, 0.65) } else { 0xFFFF5050 };
s.push(diamond(c.0, c.1, 4.0, col));
if !forecast {
s.push(diamond(c.0, c.1, 2.0, 0xFF200808));
}
taken.push([c.0 - 5.0, c.1 - 5.0, 10.0, 10.0]);
let txt = format!("{}{}", if forecast { "~" } else { "" }, if age < 20 { "сейчас".to_string() } else { format!("{} с", age / 20) });
add_lab(ui, labs, txt, c, 5.0, col, chosen);
if chosen {
s.extend(frame(c.0 - 8.0, c.1 - 8.0, 16.0, 16.0, 1.0, GREEN));
}
}
}
// ------------------------------------------------------------------ the panels
fn map_panels(&mut self, ui: &mut MapUi, s: &mut Vec<Shape>, draft: &Draft) {
let (w, h) = ui.size;
let now = self.sim.tick;
let editing = ui.mode == Mode::Editor;
let u = ui.u;
// Rows and buttons grow with the window; the text can't, so only the room round it does.
let bh = (14.0 * u).round();
let lh = (11.0 * u).round();
let narrow = w < 520.0;
// The top bar: what the map shows, always said.
s.push(fill(0.0, 0.0, w, bh, PANEL));
ui.blocked.push([0.0, 0.0, w, bh]);
let tail = {
let cw = ui.to_world(ui.cursor);
format!("x {:.0} z {:.0}", cw.0, cw.1)
};
let tail_w = ui.tw(&tail);
let heads: [&str; 2] = if self.sim.truth {
["КАРТА · ИСТИНА (песочница): красные рамки — настоящие дроны", "КАРТА · ИСТИНА"]
} else {
["КАРТА · режим: данные сети РЛС", "КАРТА · сеть РЛС"]
};
let room = w - tail_w - 20.0;
let head = if ui.tw(heads[0]) <= room { heads[0] } else { heads[1] };
s.push(text(head, 6.0, (bh - 8.0) / 2.0, if self.sim.truth { YELLOW } else { GREEN }));
if ui.tw(head) + tail_w + 20.0 <= w {
s.push(text(tail, w - tail_w - 6.0, (bh - 8.0) / 2.0, GREY));
}
// The left panel: pages of layers, filters and scenarios.
let top = bh + 4.0;
let tabs_w = 14.0 + ["Слои", "Фильтр", "Сцена"].iter().map(|t| ui.tw(t) + 14.0).sum::<f32>();
let lw = (if narrow { 150.0 } else { (w * 0.2).clamp(150.0, 190.0) }).max(tabs_w + 12.0);
let mut inner: Vec<Shape> = Vec::new();
let mut y = top;
if ui.folded {
let mut bx = 4.0;
bx += draw_btn(ui, &mut inner, "Панель", Act::Panel, false, bx, y, bh);
bx += draw_btn(ui, &mut inner, "Выход (M)", Act::Close, false, bx, y, bh);
ui.blocked.push([4.0, y, bx, bh]);
s.extend(inner);
} else {
let x0 = 8.0;
let iw = lw - 8.0;
let mut bx = x0;
bx += draw_btn(ui, &mut inner, "<", Act::Panel, false, bx, y, bh);
for (i, name) in ["Слои", "Фильтр", "Сцена"].iter().enumerate() {
bx += draw_btn(ui, &mut inner, name, Act::Tab(i), ui.tab == i, bx, y, bh);
}
y += bh + 5.0;
match ui.tab {
0 => {
inner.push(text("Слои (клавиши 1–9)", x0, y, GREY));
y += lh;
for (i, name) in FILTERS.iter().enumerate() {
let on = ui.filters[i];
let r = [x0 - 2.0, y - 1.0, iw, lh];
if hovered(ui, r) {
inner.push(fill(r[0], r[1], r[2], r[3], 0x30FFFFFF));
}
inner.push(text(format!("{} {} {}", if on { "[x]" } else { "[ ]" }, i + 1, name), x0 + 1.0, y, if on { WHITE } else { GREY }));
ui.buttons.push(Btn { rect: r, act: Act::Filter(i) });
y += lh;
}
}
1 => {
let mut sc = [0usize; 4];
for x in &self.sim.sams {
sc[sys_class(x.kind)] += 1;
}
let mut tc = [0usize; 5];
for t in self.sim.picture().values() {
tc[tgt_class(t)] += 1;
}
inner.push(text("Системы по классу", x0, y, GREY));
y += lh;
let mut x = x0;
for i in 0..SYS_CLASSES.len() {
let label = format!("{} {}", SYS_CLASSES[i], sc[i]);
let bw = ui.tw(&label) + 10.0;
if x + bw > lw {
x = x0;
y += bh + 3.0;
}
x += draw_btn(ui, &mut inner, &label, Act::SysClass(i), ui.sclass[i], x, y, bh);
}
y += bh + 6.0;
inner.push(text("Цели сети по скорости", x0, y, GREY));
y += lh;
x = x0;
for i in 0..TGT_CLASSES.len() {
let label = format!("{} {}", TGT_CLASSES[i], tc[i]);
let bw = ui.tw(&label) + 10.0;
if x + bw > lw {
x = x0;
y += bh + 3.0;
}
x += draw_btn(ui, &mut inner, &label, Act::TgtClass(i), ui.tclass[i], x, y, bh);
}
y += bh + 5.0;
for l in ["ЗРК ракеты · ЗАК пушки · тыл", "Д дроны · Г реактивные · К крылатые", "С сверхзвук · Б баллистика"] {
inner.push(text(l, x0, y, GREY));
y += lh - 1.0;
}
}
_ => {
inner.push(text("Имя сценария", x0, y, GREY));
y += lh;
let r = [x0 - 2.0, y, iw, bh];
inner.push(fill(r[0], r[1], r[2], r[3], if ui.name_focus { 0xE0302810 } else { 0xE0101814 }));
inner.extend(frame(r[0], r[1], r[2], r[3], 1.0, if ui.name_focus { YELLOW } else { 0x60FFFFFF }));
let shown = format!("{}{}", ui.name, if ui.name_focus { "_" } else { "" });
inner.push(text(shown, x0 + 3.0, y + (bh - 8.0) / 2.0, WHITE));
ui.buttons.push(Btn { rect: r, act: Act::NameFocus });
y += bh + 3.0;
let over = matches!(&ui.confirm, Some((Act::SaveScn, _)));
let save = if over { "Перезаписать?" } else { "Сохранить" };
draw_btn(ui, &mut inner, save, Act::SaveScn, over, x0 - 2.0, y, bh);
y += bh + 5.0;
if ui.scn.is_empty() {
inner.push(text("Сохранённых нет", x0, y, GREY));
y += lh;
} else {
inner.push(text(format!("Сохранённые: {}", ui.scn.len()), x0, y, GREY));
y += lh;
let first = ui.scn_page * SCN_ROWS;
for i in first..(first + SCN_ROWS).min(ui.scn.len()) {
let nm = ui.scn[i].clone();
let load = matches!(&ui.confirm, Some((Act::LoadScn(k), _)) if *k == i);
let r = [x0 - 2.0, y, iw, bh];
let hv = hovered(ui, r);
inner.push(fill(r[0], r[1], r[2], r[3], if load { 0xE0806020 } else if hv { 0xE0304038 } else { 0xE0182420 }));
inner.extend(frame(r[0], r[1], r[2], r[3], 1.0, if load { YELLOW } else { 0x60FFFFFF }));
let label = if load { "ещё раз".to_string() } else { nm };
inner.push(text(label, r[0] + 4.0, y + (bh - 8.0) / 2.0, WHITE));
ui.buttons.push(Btn { rect: r, act: Act::LoadScn(i) });
y += bh + 2.0;
}
if ui.scn.len() > SCN_ROWS {
let pages = ui.scn.len().div_ceil(SCN_ROWS);
let mut bx = x0 - 2.0;
bx += draw_btn(ui, &mut inner, "<", Act::ScnPage(-1), false, bx, y, bh);
bx += draw_btn(ui, &mut inner, ">", Act::ScnPage(1), false, bx, y, bh);
inner.push(text(format!("{}/{}", ui.scn_page + 1, pages), bx + 4.0, y + (bh - 8.0) / 2.0, GREY));
y += bh + 2.0;
}
}
}
}
y += 6.0;
// The mode buttons, in rows that wrap.
let mut bx = x0 - 2.0;
for (label, act, on) in [("Правка (E)", Act::Editor, editing), ("Игрок (C)", Act::Player, false), ("Выход (M)", Act::Close, false)] {
let bw = ui.tw(label) + 10.0;
if bx + bw > lw + 2.0 {
bx = x0 - 2.0;
y += bh + 3.0;
}
bx += draw_btn(ui, &mut inner, label, act, on, bx, y, bh);
}
y += bh + 4.0;
let panel = [4.0, top - 3.0, lw, y - top + 3.0];
s.push(fill(panel[0], panel[1], panel[2], panel[3], PANEL));
s.extend(inner);
ui.blocked.push(panel);
}
// The keys.
let helps: [&str; 3] = if editing {
["ЛКМ: ставить/переносить · ПКМ: убрать · R · Z · Enter · Esc", "ЛКМ ставить · ПКМ убрать · Enter · Esc", "Enter · Esc"]
} else {
["ЛКМ: выбор, тянуть: сдвиг · колесо: масштаб · ПКМ: марш · Esc", "ЛКМ выбор · колесо масштаб · Esc", "Esc"]
};
for help in helps {
let hw = ui.tw(help);
if hw + 12.0 <= w - 24.0 {
let r = [w / 2.0 - hw / 2.0 - 6.0, h - bh - 2.0, hw + 12.0, bh];
s.push(fill(r[0], r[1], r[2], r[3], PANEL));
s.push(text_c(help, w / 2.0, r[1] + (bh - 8.0) / 2.0, GREY));
ui.blocked.push(r);
break;
}
}
// The note.
if let Some((n, until)) = ui.note.clone() {
if now < until {
let nw = ui.tw(&n).min(w - 20.0);
let r = [w / 2.0 - nw / 2.0 - 8.0, top, nw + 16.0, bh + 2.0];
s.push(fill(r[0], r[1], r[2], r[3], 0xE0302010));
s.push(text_c(n, w / 2.0, top + (bh - 6.0) / 2.0, YELLOW));
ui.blocked.push(r);
} else {
ui.note = None;
}
}
// The right card.
let card_w = if narrow { 150.0 } else { (w * 0.2).clamp(170.0, 250.0) };
let cx = w - card_w - 2.0;
let mut lines: Vec<(String, u32)> = Vec::new();
let mut btns: Vec<(String, Act, bool)> = Vec::new();
if editing {
self.editor_card(ui, draft, &mut lines, &mut btns);
} else {
self.sel_card(ui, &mut lines, &mut btns);
}
// Long lines break at the card's width.
let mut wrapped: Vec<(String, u32)> = Vec::new();
for (l, c) in lines {
let mut cur = String::new();
for word in l.split(' ') {
let try_ = if cur.is_empty() { word.to_string() } else { format!("{cur} {word}") };
if ui.tw(&try_) > card_w - 8.0 && !cur.is_empty() {
wrapped.push((std::mem::take(&mut cur), c));
cur = word.to_string();
} else {
cur = try_;
}
}
wrapped.push((cur, c));
}
let lines = wrapped;
if !lines.is_empty() || !btns.is_empty() {
let mut y = top;
let ch = lines.len() as f32 * lh + 10.0;
// Buttons go in rows that wrap.
let mut rows: Vec<Vec<(String, Act, bool, f32)>> = vec![Vec::new()];
let mut used = 0.0;
for (l, a, on) in btns {
let bw = ui.tw(&l) + 10.0;
if used + bw > card_w - 6.0 && !rows.last().unwrap().is_empty() {
rows.push(Vec::new());
used = 0.0;
}
rows.last_mut().unwrap().push((l, a, on, bw));
used += bw + 4.0;
}
let total = ch + rows.iter().filter(|r| !r.is_empty()).count() as f32 * (bh + 4.0) + 4.0;
let panel = [cx - 3.0, y - 3.0, card_w + 2.0, total];
s.push(fill(panel[0], panel[1], panel[2], panel[3], PANEL));
ui.blocked.push(panel);
for (l, c) in &lines {
s.push(text(l.as_str(), cx, y, *c));
y += lh;
}
y += 6.0;
for row in rows {
let mut x = cx;
for (l, a, on, _) in row {
x += draw_btn(ui, s, &l, a, on, x, y, bh);
}
y += bh + 4.0;
}
}
// The editor's palette along the bottom.
if editing {
let mut kinds: Vec<(String, Pick)> = SamKind::ALL.iter().map(|k| (short_name(*k).to_string(), Pick::Sam(*k))).collect();
kinds.push(("Объект".into(), Pick::Object));
// Rows first, so the palette sits just above the help line.
let mut rows = 1;
let mut used = 6.0;
for (label, _) in &kinds {
let bw = ui.tw(label) + 10.0;
if used + bw > w - 4.0 {
rows += 1;
used = 6.0;
}
used += bw + 4.0;
}
let mut x = 6.0;
let mut y = h - bh - 4.0 - rows as f32 * (bh + 2.0);
let panel = [0.0, y - 3.0, w, rows as f32 * (bh + 2.0) + 4.0];
s.push(fill(panel[0], panel[1], panel[2], panel[3], PANEL));
ui.blocked.push(panel);
for (label, pick) in kinds {
let bw = ui.tw(&label) + 10.0;
if x + bw > w - 4.0 {
x = 6.0;
y += bh + 2.0;
}
let on = ui.pick == pick;
let r = [x, y, bw, bh];
let hv = hovered(ui, r);
s.push(fill(r[0], r[1], r[2], r[3], if on { 0xE0806020 } else if hv { 0xE0304038 } else { 0xE0182420 }));
s.extend(frame(r[0], r[1], r[2], r[3], 1.0, if on { YELLOW } else { 0x60FFFFFF }));
s.push(text(label, x + 5.0, y + (bh - 8.0) / 2.0, WHITE));
ui.buttons.push(Btn { rect: r, act: Act::Pick(pick) });
x += bw + 4.0;
}
}
}
fn editor_card(&self, ui: &MapUi, d: &Draft, lines: &mut Vec<(String, u32)>, btns: &mut Vec<(String, Act, bool)>) {
lines.push(("РАССТАНОВКА ДО БОЯ".into(), YELLOW));
lines.push(("Пока не подтвердите, ничего не строится.".into(), GREY));
let new_s = d.sams.iter().filter(|s| s.id.is_none() && !s.gone).count();
let gone_s = d.sams.iter().filter(|s| s.id.is_some() && s.gone).count();
let new_o = d.objs.iter().filter(|o| o.idx.is_none() && !o.gone).count();
let gone_o = d.objs.iter().filter(|o| o.idx.is_some() && o.gone).count();
lines.push((format!("Новых: комплексов {new_s}, объектов {new_o}"), WHITE));
lines.push((format!("Убрать: комплексов {gone_s}, объектов {gone_o}"), WHITE));
if self.draft_changed(ui) {
lines.push(("Есть неподтверждённые изменения".into(), ORANGE));
}
// The gaps: objects no system reaches.
let bare = d
.objs
.iter()
.filter(|o| !o.gone)
.filter(|o| !d.sams.iter().any(|s| !s.gone && reaches(s.kind, s.pos, o.pos)))
.count();
lines.push((if bare == 0 { "Все объекты в зоне поражения".into() } else { format!("Без прикрытия: объектов {bare} (красные)") }, if bare == 0 { GREEN } else { RED }));
lines.push(("Зелёное: зона огня, тёмное: дыра".into(), GREY));
match ui.pick {
Pick::Sam(k) => lines.push((format!("В руке: {}, дальность {}", k.name(), distance(k.range())), YELLOW)),
Pick::Object => lines.push(("В руке: объект (его будут защищать)".into(), YELLOW)),
Pick::None => lines.push(("Выберите тип внизу".into(), GREY)),
}
btns.push(("Готово (Enter)".into(), Act::Confirm, false));
btns.push(("Отмена".into(), Act::Cancel, false));
btns.push(("Назад (Z)".into(), Act::Undo, false));
btns.push(("Поворот (R)".into(), Act::Rotate, false));
btns.push(("Убрать (Del)".into(), Act::Delete, false));
}
fn sel_card(&self, ui: &MapUi, lines: &mut Vec<(String, u32)>, btns: &mut Vec<(String, Act, bool)>) {
let now = self.sim.tick;
match ui.sel {
Some(Sel::Sam(id)) => {
let Some((n, sam)) = self.sim.sams.iter().enumerate().find(|(_, s)| s.id == id) else { return };
let k = sam.kind;
lines.push((format!("{} №{}", k.name(), n + 1), CYAN));
lines.push((sam.status(), WHITE));
lines.push((format!("Исправен {:.0}% · {:.0} {:.0}", sam.health * 100.0, sam.pos.x, sam.pos.z), GREY));
if k.armed() {
if sam.kind == SamKind::S400 { lines.push((format!("Ударных RM48U: {} (общие ячейки с ПВО)", sam.ground_rounds), WHITE)); }
lines.push((format!("Боезапас: {} ракет, {} очередей{}", sam.missiles, sam.bursts, if sam.reloading > 0 { format!(" · перезарядка {} с", sam.reloading / 20) } else { String::new() }), WHITE));
lines.push((format!("Дальность огня: {}", distance(k.range())), WHITE));
}
if k.spec().sensor > 0.0 {
lines.push((format!("Свой обзор: {} (зелёное кольцо)", distance(k.spec().sensor)), WHITE));
}
if let Some(t) = sam.gun_target.or(sam.target) {
lines.push((format!("Ведёт цель: трек №{t}"), YELLOW));
}
if k.armed() {
lines.push(("Роли (кнопки): Д дроны, Г реактивные, К крылатые, С сверхзвук, Б баллистика".into(), GREY));
lines.push((format!("Доктрина: {}", sam.doctrine.text(&self.sim.targets)), WHITE));
for c in Class::ALL {
btns.push((c.letter().to_string(), Act::Role(c.bit()), sam.roles & c.bit() != 0));
}
btns.push(("Охрана".into(), Act::Guard, matches!(ui.mode, Mode::Guard(i) if i == id)));
btns.push(("Сектор".into(), Act::Sector, matches!(ui.mode, Mode::Sector(i, _) if i == id)));
btns.push(("Без сектора".into(), Act::SectorOff, false));
btns.push((format!("Резерв {}", sam.doctrine.reserve), Act::Reserve, false));
btns.push((format!("Залп: {}", sam.doctrine.salvo.name()), Act::Salvo, false));
btns.push(("Сброс".into(), Act::ResetDoc, false));
match ui.mode {
Mode::Guard(_) => lines.push(("Нажимайте объекты на карте: охранять / не охранять. Esc — готово.".into(), YELLOW)),
Mode::Sector(_, None) => lines.push(("Сектор: щёлкните в сторону центра сектора.".into(), YELLOW)),
Mode::Sector(_, Some(_)) => lines.push(("Сектор: щёлкните, чтобы задать ширину.".into(), YELLOW)),
_ => {}
}
}
if k.mobile() {
lines.push(("ПКМ по земле — отправить на марш".into(), GREY));
}
}
Some(Sel::Object(i)) => {
let Some(p) = self.sim.targets.get(i) else { return };
lines.push((format!("Объект №{}", i + 1), WHITE));
lines.push((format!("Прочность: {:.0}% {:.0} {:.0}", self.sim.target_health.get(i).copied().unwrap_or(100.0), p.x, p.z), GREY));
let cover: Vec<String> = self.sim.sams.iter().filter(|s| s.alive() && reaches(s.kind, s.pos, *p)).map(|s| s.kind.name().to_string()).collect();
if cover.is_empty() {
lines.push(("НЕ ПРИКРЫТ: ни один комплекс не достаёт".into(), RED));
} else {
lines.push((format!("Прикрыт: {}", cover.join(", ")), GREEN));
}
let guards = self.sim.sams.iter().filter(|s| s.doctrine.guards.iter().any(|g| g.distance(*p) < 16.0)).count();
if guards > 0 {
lines.push((format!("Охраняют по доктрине: {guards}"), WHITE));
}
}
Some(Sel::Site(id)) => {
let Some(k) = self.sim.strikes.get(id) else { return };
lines.push((format!("Пусковая №{id}: {}", class_name(k.class)), ORANGE));
match (&k.est, k.state) {
(Some(e), st) => {
if e.fix {
lines.push((format!("Место известно: {:.0} {:.0} ± {}", e.pos.x, e.pos.y, distance(e.radius)), WHITE));
} else {
lines.push((format!("Места не знаем, только азимут {:.0}°", e.bearing.to_degrees()), YELLOW));
}
lines.push((format!("Точность: {}", sim::strike::accuracy(e)), WHITE));
lines.push((
match st {
SiteState::Active => "Состояние: действует".to_string(),
SiteState::Stunned(t) => format!("Состояние: подавлена ещё {} с", t.saturating_sub(now) / 20),
SiteState::Destroyed(_) => "Состояние: уничтожена".to_string(),
},
WHITE,
));
}
(None, _) => lines.push(("Данных нет".into(), GREY)),
}
lines.push((format!("Пусков замечено: {}; последний {} с назад", k.launches, now.saturating_sub(k.last) / 20), GREY));
lines.push(("Для удара нужен готовый С-400 с RM48U".into(), GREY));
if k.aimed {
lines.push(("Ракета по ней уже в полёте".into(), YELLOW));
}
if k.est.is_some_and(|e| e.fix) && !matches!(k.state, SiteState::Destroyed(_)) {
btns.push(("Нанести удар".into(), Act::Strike(id), false));
}
btns.push(("В центр".into(), Act::Centre, false));
}
Some(Sel::Track(id)) => {
let pic = self.sim.picture();
let Some(t) = pic.get(&id) else {
lines.push((format!("Трек №{id}: потерян сетью"), GREY));
return;
};
lines.push((format!("Трек сети №{id}"), 0xFFFF8080));
lines.push((format!("Опознание: {}", t.ident().name()), WHITE));
let age = t.age(now);
lines.push((
if t.forecast(now) { format!("ПРОГНОЗ: последнее измерение {} с назад", age / 20) } else { format!("Измерение {} с назад", age / 20) },
if t.forecast(now) { YELLOW } else { GREEN },
));
lines.push((format!("Высота {:.0} м, скорость {:.0} км/ч", t.pos.y, t.vel.length() * 20.0 * 3.6), WHITE));
lines.push((format!("Погрешность места до {}", distance(t.uncertainty(now))), GREY));
lines.push(("Цель и маршрут неизвестны сети: тонкая линия —".into(), GREY));
lines.push(("пройденное по измерениям, пунктир — прогноз курса.".into(), GREY));
if let Some(trail) = ui.trails.get(&id) {
lines.push((format!("Точек измерений: {}", trail.len()), GREY));
}
let who = self.who_tracks(t);
if !who.is_empty() {
lines.push((format!("Держат: {who}"), WHITE));
}
btns.push(("В центр".into(), Act::Centre, false));
btns.push(("Следить (F)".into(), Act::Follow, ui.follow));
}
None => {
let live = self.sim.strikes.known.iter().filter(|k| !matches!(k.state, SiteState::Destroyed(_))).count();
lines.push(("Ничего не выбрано".into(), GREY));
lines.push((format!("Комплексов: {} · объектов: {}", self.sim.sams.len(), self.sim.targets.len()), WHITE));
lines.push((format!("Целей у сети: {} · известных ПУ: {live}", self.sim.picture().len()), WHITE));
if self.battle() {
lines.push(("Идёт налёт: расстановка закрыта".into(), YELLOW));
}
}
}
}
/// The systems whose tracks hold this one, by name (the network's own bookkeeping, not the drone's).
fn who_tracks(&self, t: &Track) -> String {
let n = self.sim.sams.iter().filter(|s| s.tracks.iter().any(|x| x.id == t.id)).count();
if n == 0 { String::new() } else { format!("{n} комплексов") }
}
}
fn remove_dsam(d: &mut Draft, i: usize) {
if let Some(s) = d.sams.get_mut(i) {
if s.id.is_some() {
s.gone = true;
} else {
d.sams.remove(i);
}
}
}
fn remove_dobj(d: &mut Draft, i: usize) {
if let Some(o) = d.objs.get_mut(i) {
if o.idx.is_some() {
o.gone = true;
} else {
d.objs.remove(i);
}
}
}
fn sim_angle_diff(from: f64, to: f64) -> f64 {
(to - from + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI
}
/// A button at (x, y) as high as `bh`; registers its click and returns the room it takes (with the gap after it).
fn draw_btn(ui: &mut MapUi, s: &mut Vec<Shape>, label: &str, act: Act, on: bool, x: f32, y: f32, bh: f32) -> f32 {
let bw = ui.tw(label) + 10.0;
let r = [x, y, bw, bh];
let hv = hovered(ui, r);
s.push(fill(r[0], r[1], r[2], r[3], if on { 0xE0306040 } else if hv { 0xE0304038 } else { 0xE0182420 }));
s.extend(frame(r[0], r[1], r[2], r[3], 1.0, if on { GREEN } else { 0x60FFFFFF }));
s.push(text(label, x + 5.0, y + (bh - 8.0) / 2.0, WHITE));
ui.buttons.push(Btn { rect: r, act });
bw + 4.0
}
fn hovered(ui: &MapUi, r: [f32; 4]) -> bool {
ui.cursor.0 >= r[0] && ui.cursor.0 <= r[0] + r[2] && ui.cursor.1 >= r[1] && ui.cursor.1 <= r[1] + r[3]
}
/// A circle of `r` pixels round `c`, only the parts on the screen.
fn ring(ui: &MapUi, s: &mut Vec<Shape>, c: (f32, f32), r: f32, w: f32, color: u32) {
if !r.is_finite() || r < 2.0 {
return;
}
// Wholly off the screen: the nearest the circle comes is |distance to the middle - r|.
let mid = (ui.size.0 / 2.0, ui.size.1 / 2.0);
let far = (c.0 - mid.0).hypot(c.1 - mid.1);
let reach = mid.0.hypot(mid.1);
if far - r > reach || r - far > reach {
return;
}
let n = ((r / 5.0) as usize).clamp(16, 120);
let mut prev = (c.0, c.1 - r);
for i in 1..=n {
let a = i as f32 / n as f32 * TAU;
let p = (c.0 + a.sin() * r, c.1 - a.cos() * r);
if ui.on_screen(p, 40.0) || ui.on_screen(prev, 40.0) {
s.push(line(prev, p, w, color));
}
prev = p;
}
}
fn dashed(s: &mut Vec<Shape>, a: (f32, f32), b: (f32, f32), color: u32) {
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let len = dx.hypot(dy);
let n = ((len / 8.0) as usize).min(200);
for i in (0..n).step_by(2) {
let (t0, t1) = (i as f32 / n as f32, (i + 1) as f32 / n as f32);
s.push(line((a.0 + dx * t0, a.1 + dy * t0), (a.0 + dx * t1, a.1 + dy * t1), 1.0, color));
}
}
#[cfg(test)]
mod tests {
use super::*;
fn labels(n: usize) -> (Vec<Lab>, Vec<(f32, f32)>) {
// 128 systems of a polygon in a few clumps, each with the long name that overlapped before.
let pos: Vec<(f32, f32)> = (0..n).map(|i| (300.0 + (i % 16) as f32 * 14.0 + (i / 64) as f32 * 3.0, 200.0 + (i / 16) as f32 * 13.0)).collect();
let labs = pos
.iter()
.enumerate()
.map(|(i, p)| Lab { text: "РЛС дальнего обнаружения".into(), w: 24.0 * 6.0, at: *p, r: 7.0, col: WHITE, prio: ((p.0 - 400.0).hypot(p.1 - 250.0)) + i as f32 * 0.001 })
.collect();
(labs, pos)
}
#[test]
fn labels_never_overlap_and_are_capped() {
let (labs, pos) = labels(128);
let mut taken: Vec<[f32; 4]> = pos.iter().map(|p| [p.0 - 5.0, p.1 - 5.0, 10.0, 10.0]).collect();
taken.push([0.0, 0.0, 1000.0, 14.0]);
let mut out = Vec::new();
let t = std::time::Instant::now();
place_labels((1000.0, 560.0), labs, taken.clone(), &mut out);
eprintln!("128 labels placed in {:?}, {} shown", t.elapsed(), out.len());
assert!(out.len() <= MAX_LABELS);
let rects: Vec<[f32; 4]> = out
.iter()
.map(|s| match s {
Shape::Text(t) => [t.at.x, t.at.y, 144.0, LH],
_ => unreachable!(),
})
.collect();
for (i, a) in rects.iter().enumerate() {
assert!(taken.iter().all(|m| !overlap(*a, *m)), "label {i} covers a marker or panel");
for b in &rects[i + 1..] {
assert!(!overlap(*a, *b), "two labels overlap");
}
}
}
#[test]
fn crowded_markers_merge_and_the_selected_one_stays_alone() {
let pos: Vec<(f32, f32)> = (0..128).map(|i| (300.0 + (i % 16) as f32 * 3.0, 200.0 + (i / 16) as f32 * 3.0)).collect();
let mut solo = vec![false; 128];
solo[40] = true;
let t = std::time::Instant::now();
let g = groups_of(&pos, &solo, CLUSTER_R, true);
eprintln!("128 markers grouped in {:?} into {}", t.elapsed(), g.len());
assert!(g.len() < 20 && g.iter().any(|x| x == &vec![40]));
assert_eq!(g.iter().map(Vec::len).sum::<usize>(), 128);
// Zoomed in, they stand apart.
let far: Vec<(f32, f32)> = (0..128).map(|i| (i as f32 * 30.0, 0.0)).collect();
assert_eq!(groups_of(&far, &vec![false; 128], CLUSTER_R, true).len(), 128);
}
}