Files
airdef/airdef-mod/src/lib.rs
T

1367 lines
60 KiB
Rust
Raw Permalink 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.
//! AirDef: long-range drones and air defence, drawn as 3D models through the
//! AirDef fork's `render.set-models`. The simulation is `sim`; this file is
//! the glue: the player's items and commands, the HUD, saving, and handing
//! the simulation's output to the game.
use glam::DVec3;
use horizon_mod_sdk::{
Mod, Registration, chat, command, game,
hud::{self, Corner},
input::{self, Event},
render::{self, Lighting, ModelInstance, ParticleSpawn, PointLight},
storage,
ui::{self, ButtonWidget, ItemWidget, ListWidget, Screen, Widget},
};
mod monitor;
mod panel;
mod radar;
mod replay;
mod sim;
mod wave;
use sim::{Class, DroneKind, Ground, Out, Sam, SamKind, Sim};
const ITEMS: [&str; 29] = [
"airdef:designator",
"airdef:launch_shahed",
"airdef:launch_geran3",
"airdef:launch_lancet",
"airdef:launch_kh101",
"airdef:launch_kalibr",
"airdef:launch_kh22",
"airdef:launch_zircon",
"airdef:launch_iskander",
"airdef:launch_kinzhal",
"airdef:launch_oreshnik",
"airdef:deploy_patriot",
"airdef:deploy_gepard",
"airdef:deploy_pantsir",
"airdef:deploy_s400",
"airdef:deploy_s500",
"airdef:deploy_irist",
"airdef:deploy_nasams",
"airdef:deploy_buk",
"airdef:deploy_tor",
"airdef:deploy_p1sun",
"airdef:deploy_radar",
"airdef:deploy_depot",
"airdef:deploy_tzm",
"airdef:deploy_ew",
"airdef:deploy_light",
"airdef:mover",
"airdef:flare_gun",
"airdef:remover",
];
struct AirDef {
sim: Sim,
ground: Ground,
dirty: bool,
hud_shown: bool,
/// The system the monitor shows (K cycles), none: hidden.
monitor: Option<usize>,
monitor_shown: bool,
/// Every system's monitor in a grid (J).
grid: bool,
/// The systems the grid shows (ids), the busiest, chosen every few seconds.
grid_ids: Vec<u32>,
/// The raid the wave menu orders.
wave: wave::WaveConfig,
/// A replay playing (it takes the screen and the mouse wheel).
replay: Option<replay::Player>,
/// The world drawn beyond the render distance (replays and cameras see far off).
far: bool,
/// The unit the move remote picked (its id), waiting for where to go.
moving: Option<u32>,
/// The HD lighting preset (the engine's lights, bloom, tone mapping).
hd: bool,
/// The world whose state is loaded (`game.world-id`), once one is.
world: Option<Option<String>>,
/// The systems' and objects' health as last saved, to save again when it changes.
health_mark: u64,
/// The menu's page while it is open.
menu: Option<Page>,
/// Where the player is, for the sounds' delay and far variants.
listener: DVec3,
/// Sounds on their way to the player at the speed of sound: (tick, event, at, pitch).
pending: Vec<(u64, String, DVec3, f32)>,
}
/// Blocks a tick the sound travels (343 m/s).
const SOUND_SPEED: f64 = 17.15;
/// Past this the far variant plays: muffled, more rolling echo.
const FAR: f64 = 140.0;
/// Impulsive sounds (blasts, launches, shots, shock waves) come late from afar and have far variants.
fn travels(event: &str) -> bool {
["airdef:blast", "airdef:launch", "airdef:gun", "airdef:boom"].iter().any(|p| event.starts_with(p))
}
/// A page of the menu.
#[derive(Clone, Copy, PartialEq)]
enum Page {
Main,
Roles(SamKind),
/// The raid's make-up, then its parameters and the launch.
Wave,
WaveGo,
/// Fire, repair, effects, damage.
More,
/// The last raid's events and its replays.
Replays,
}
const MENU_KINDS: u32 = 1;
const BTN_HOLD: u32 = 10;
const BTN_SHADER: u32 = 11;
const BTN_DAMAGE: u32 = 12;
const BTN_MONITOR: u32 = 13;
const BTN_GRID: u32 = 14;
const BTN_WAVE: u32 = 15;
const BTN_REPAIR: u32 = 16;
const WAVE_KINDS: u32 = 2;
const BTN_PRESET: u32 = 30;
const BTN_APPROACH: u32 = 31;
const BTN_DIST: u32 = 32;
const BTN_AIM: u32 = 33;
const BTN_LAUNCH: u32 = 34;
const BTN_NEXT: u32 = 35;
const BTN_MORE: u32 = 17;
const BTN_REPLAYS: u32 = 18;
const REPLAY_EVENTS: u32 = 3;
const BTN_MAP: u32 = 40;
const BTN_FULL: u32 = 41;
const BTN_REEL: u32 = 42;
const BTN_FAR: u32 = 19;
const BTN_CLASS: u32 = 100;
const BTN_ALL: u32 = 120;
const BTN_DEFAULT: u32 = 121;
const BTN_NONE: u32 = 122;
const BTN_BACK: u32 = 199;
fn say(text: &str) {
chat::show(text);
}
fn player() -> Option<game::Player> {
game::get_player()
}
fn eye(p: &game::Player) -> DVec3 {
DVec3::new(p.x, p.y + 1.62, p.z)
}
/// The player's view direction (Minecraft's yaw and pitch, degrees).
fn view(p: &game::Player) -> DVec3 {
let (yaw, pitch) = (f64::from(p.yaw).to_radians(), f64::from(p.pitch).to_radians());
DVec3::new(-yaw.sin() * pitch.cos(), -pitch.sin(), yaw.cos() * pitch.cos())
}
/// Where the crosshair meets a block, up to 512 blocks.
fn aim() -> Option<DVec3> {
game::raycast(512.0).map(|h| DVec3::new(h.x, h.y, h.z))
}
impl AirDef {
fn use_item(&mut self, id: &str) {
let Some(p) = player() else { return };
let mut out = Out::default();
match id {
"airdef:designator" => match aim() {
Some(at) => {
if let Some(i) = self.sim.targets.iter().position(|t| t.distance(at) < 3.0) {
self.sim.targets.remove(i);
if i < self.sim.target_health.len() {
self.sim.target_health.remove(i);
}
say("Цель снята");
} else {
self.sim.targets.push(at);
self.sim.target_health.push(100.0);
say(&format!("Цель отмечена: {:.0} {:.0} {:.0}", at.x, at.y, at.z));
}
self.dirty = true;
}
None => say("Нет блока под прицелом"),
},
_ if id.starts_with("airdef:launch_") => {
let Some(kind) = DroneKind::from_key(&id["airdef:launch_".len()..]) else { return };
// Where you look, else the nearest marked target.
let target = aim().or_else(|| self.sim.nearest_target(eye(&p)));
match target {
Some(t) => {
let from = eye(&p) + view(&p) * 2.0 + DVec3::Y;
self.sim.launch(kind, from, view(&p), t, &mut out);
}
None => say("Наведитесь на блок или отметьте цель"),
}
}
_ if id.starts_with("airdef:deploy_") => {
let Some(kind) = SamKind::from_key(&id["airdef:deploy_".len()..]) else { return };
match aim() {
Some(at) => {
let d = view(&p);
let heading = (-d.x).atan2(-d.z);
let sid = self.sim.id();
let mut sam = Sam::new(sid, kind, at, heading);
if let Some(r) = self.sim.roles.get(&kind) {
sam.roles = *r;
}
self.sim.sams.push(sam);
out.sound("minecraft:block.anvil.place", at, 2.0, 0.7);
say(&format!("{} развёрнут", kind.name()));
self.dirty = true;
}
None => say("Наведитесь на землю, где поставить комплекс"),
}
}
"airdef:mover" => {
let Some(at) = aim() else {
say("Наведитесь на технику или на точку на земле");
return;
};
let near = self
.sim
.sams
.iter()
.enumerate()
.filter(|(_, s)| s.pos.distance(at) < 6.0 && s.alive())
.min_by(|a, b| a.1.pos.distance(at).total_cmp(&b.1.pos.distance(at)))
.map(|(i, s)| (i, s.id));
match (near, self.moving) {
// A unit pointed at: picked (or another picked instead).
(Some((i, id)), _) => {
let s = &self.sim.sams[i];
if s.kind.mobile() {
self.moving = Some(id);
say(&format!("{} №{} выбран: укажите, куда ехать", s.kind.name(), i + 1));
} else {
say(&format!("{} не перемещается", s.kind.name()));
}
}
// The ground: the picked unit drives there.
(None, Some(id)) => {
if let Some(i) = self.sim.sams.iter().position(|s| s.id == id)
&& self.sim.order_move(i, at)
{
let s = &self.sim.sams[i];
say(&format!("{} №{}: свёртывание и марш, {}", s.kind.name(), i + 1, panel::distance(s.pos.distance(at))));
out.sound("minecraft:ui.button.click", at, 1.0, 1.0);
}
self.moving = None;
}
(None, None) => say("Сначала наведитесь на технику, которую перемещать"),
}
}
"airdef:flare_gun" => {
self.sim.fire_flare(eye(&p) + view(&p), view(&p), &mut out);
}
"airdef:remover" => {
let at = aim().unwrap_or(eye(&p));
if let Some(i) = self
.sim
.sams
.iter()
.enumerate()
.filter(|(_, s)| s.pos.distance(at) < 10.0)
.min_by(|a, b| a.1.pos.distance(at).total_cmp(&b.1.pos.distance(at)))
.map(|(i, _)| i)
{
let s = self.sim.sams.remove(i);
say(&format!("{} свёрнут", s.kind.name()));
self.dirty = true;
} else {
say("Рядом нет комплекса ПВО");
}
}
_ => {}
}
self.emit(out);
}
/// The HD lighting's lights: flames, glowing warheads, flares, muzzle flashes, tracers,
/// blasts (a flash, then the fireball's glow dying down), burning wrecks and the
/// searchlights' spots.
fn lights(&self, out: &Out) -> Vec<PointLight> {
let mut lights: Vec<PointLight> = Vec::new();
let mut add = |id: u32, at: DVec3, rgb: (f32, f32, f32), intensity: f32, radius: f32| {
if lights.len() < 500 && intensity > 0.05 {
lights.push(PointLight { id, x: at.x, y: at.y, z: at.z, color: rgb, intensity, radius: radius.clamp(1.0, 256.0) });
}
};
let tick = self.sim.tick;
let flicker = |id: u32| 0.85 + 0.15 * (((tick as u32).wrapping_mul(2654435761) ^ id.wrapping_mul(97)) % 100) as f32 / 100.0;
for m in out.models.iter().filter(|m| m.glow) {
let s = m.scale.max(0.1);
match m.name {
"airdef:flame" => add(m.id, m.at, (1.0, 0.55, 0.2), 45.0 * s * flicker(m.id), 32.0 * s.sqrt()),
"airdef:geran3_flame" => add(m.id, m.at, (1.0, 0.6, 0.25), 25.0 * s * flicker(m.id), 22.0),
"airdef:reentry" => add(m.id, m.at, (1.0, 0.6, 0.32), 60.0 * s, 40.0),
"airdef:flare" => add(m.id, m.at, (1.0, 0.93, 0.78), 420.0 * s, 110.0),
"airdef:flash" => add(m.id, m.at, (1.0, 0.8, 0.45), 30.0, 14.0),
"airdef:tracer" => add(m.id, m.at, (1.0, 0.25, 0.1), 2.5, 6.0),
_ => {}
}
}
for b in &self.sim.blasts {
let age = tick.saturating_sub(b.start) as f32;
let size = b.size;
let glow = (-age / (b.life as f32 * 0.15).max(1.0)).exp();
let flash = (-age * 0.35).exp() * 4.0;
let id = 0x6100_0000 ^ (b.start as u32).wrapping_mul(31) ^ (b.at.x as i32 as u32).wrapping_mul(7);
add(id, b.at + DVec3::Y * size as f64 * 0.5, (1.0, 0.58, 0.25), size * size * 18.0 * (glow + flash), size * 14.0);
}
for s in &self.sim.sams {
if !s.alive() && s.burning() {
add(s.id + 15, s.pos + DVec3::Y * 1.5, (1.0, 0.5, 0.18), 80.0 * flicker(s.id), 30.0);
}
// A searchlight's spot where its beam meets the target.
if s.kind == SamKind::Light
&& let Some(t) = s.target.and_then(|t| self.sim.drones.iter().find(|d| d.id == t))
&& self.sim.lit.contains(&t.id)
{
add(s.id + 14, t.pos, (0.95, 0.97, 1.0), 220.0, 30.0);
}
}
lights
}
/// The effects preset: none, the post pass, or the post pass under the HD lighting.
fn set_effects(&mut self, shader: bool, hd: bool) {
self.sim.shader = shader;
if shader {
render::set_post(include_str!("../shaders/effects.wgsl"));
} else {
render::clear_post();
}
self.hd = shader && hd;
self.apply_hd();
self.dirty = true;
}
/// Switches the HD lighting.
fn apply_hd(&self) {
render::set_lighting(Lighting { hd: self.hd, exposure: 1.0, bloom: 0.55 });
if !self.hd {
render::set_lights(&[]);
}
}
/// Hands the simulation's output to the game.
/// The post pass's parameters: blasts and glowing parts (shaders/effects.wgsl).
fn shader_params(&self, out: &Out) -> Vec<f32> {
let mut p = vec![0.0f32; 4];
p[0] = self.sim.tick as f32;
p[3] = if self.hd { 1.0 } else { 0.0 };
let blasts: Vec<&sim::Blast> = self.sim.blasts.iter().rev().take(48).collect();
p[1] = blasts.len() as f32;
for b in &blasts {
p.extend([b.at.x as f32, b.at.y as f32, b.at.z as f32, b.size]);
p.extend([b.start as f32, b.life as f32, 0.0, 0.0]);
}
p.resize(4 * 97, 0.0);
let mut lights = 0;
for m in out.models.iter().filter(|m| m.glow) {
if lights >= 79 {
break;
}
let (r, g, b, i) = match m.name {
"airdef:flame" | "airdef:geran3_flame" => (1.0, 0.55, 0.18, 1.2),
"airdef:flash" => (1.0, 0.85, 0.5, 2.0),
"airdef:target" => (1.0, 0.1, 0.1, 0.5),
"airdef:tracer" => (1.0, 0.12, 0.05, 0.9),
"airdef:reentry" => (1.0, 0.6, 0.3, 1.4),
"airdef:flare" => (1.0, 0.94, 0.78, 1.2),
_ => continue,
};
// The shader lights about six times the radius round a light and draws a glow of
// its radius: a flare lights some sixty blocks round, the rest about their size.
let radius = if m.name == "airdef:flare" { 10.0 } else { m.scale * 1.6 };
p.extend([m.at.x as f32, m.at.y as f32, m.at.z as f32, radius]);
p.extend([r, g, b, i]);
lights += 1;
}
p[2] = lights as f32;
p
}
fn emit(&mut self, out: Out) {
if self.sim.shader {
render::set_params(&self.shader_params(&out));
}
if self.hd {
render::set_lights(&self.lights(&out));
}
let models: Vec<ModelInstance> = out
.models
.into_iter()
.map(|m| {
let r = m.rotation.as_quat();
ModelInstance {
id: m.id,
model: m.name.to_string(),
x: m.at.x,
y: m.at.y,
z: m.at.z,
rotation: (r.x, r.y, r.z, r.w),
scale: m.scale,
glow: m.glow,
}
})
.collect();
if !models.is_empty() || self.sim.tick % 20 == 0 {
render::set_models(&models);
}
if !out.particles.is_empty() {
let spawns: Vec<ParticleSpawn> = out
.particles
.into_iter()
.take(512)
.map(|p| ParticleSpawn {
particle: p.kind.to_string(),
x: p.at.x,
y: p.at.y,
z: p.at.z,
spread: (p.spread[0], p.spread[1], p.spread[2]),
velocity: (p.velocity.x as f32, p.velocity.y as f32, p.velocity.z as f32),
speed: p.speed,
count: p.count,
color: p.color,
scale: p.scale,
})
.collect();
render::spawn_particles(&spawns);
}
let now = self.sim.tick;
for (event, at, volume, pitch) in out.sounds {
let dist = at.distance(self.listener);
if travels(event) {
// Seen first, heard later; from afar muffled.
let name = if dist > FAR { format!("{event}_far") } else { event.to_string() };
let delay = (dist / SOUND_SPEED) as u64;
if delay == 0 {
render::play_sound(&name, at.x, at.y, at.z, volume, pitch);
} else if self.pending.len() < 256 {
self.pending.push((now + delay, name, at, pitch));
}
} else {
render::play_sound(event, at.x, at.y, at.z, volume, pitch);
}
}
let mut i = 0;
while i < self.pending.len() {
if self.pending[i].0 <= now {
let (_, name, at, pitch) = self.pending.swap_remove(i);
render::play_sound(&name, at.x, at.y, at.z, 1.0, pitch);
} else {
i += 1;
}
}
if !out.commands.is_empty() {
command::run_quiet(&out.commands);
}
if let Some((strength, seconds)) = out.shake {
render::shake(strength, seconds);
}
for m in out.messages {
say(&m);
}
}
fn draw_hud(&mut self, player: DVec3, yaw: f32) {
let air: Vec<&sim::Drone> = self.sim.drones.iter().filter(|d| d.alive()).collect();
// The command post's grid and replays cover the screen: the other panels wait under them.
if self.grid || self.replay.is_some() || (air.is_empty() && self.sim.sams.is_empty() && self.sim.missiles.is_empty()) {
if self.hud_shown {
hud::clear();
render::clear_corner();
self.hud_shown = false;
}
return;
}
self.hud_shown = true;
hud::set_panel(Corner::TopRight, &panel::summary(&self.sim, &air, player));
render::set_corner(render::Corner::BottomRight, radar::SIZE, radar::SIZE + 12.0, &radar::draw(&self.sim, player, yaw));
}
// ------------------------------------------------ saving
fn save(&mut self) {
let mut text = String::new();
for s in &self.sim.sams {
// Then its ammunition (missiles, bursts, out and waiting for a truck, reload ticks
// left) and where it was driving, if anywhere.
let dest = s.dest.map_or("- - -".to_string(), |d| format!("{} {} {}", d.x, d.y, d.z));
text += &format!(
"sam {} {} {} {} {} {} {} {} {} {} {} {} {dest}\n",
s.kind.key(),
s.pos.x,
s.pos.y,
s.pos.z,
s.heading,
s.roles,
s.health,
s.cargo,
s.missiles,
s.bursts,
u8::from(s.empty),
s.reloading,
);
}
for (i, t) in self.sim.targets.iter().enumerate() {
let h = self.sim.target_health.get(i).copied().unwrap_or(100.0);
text += &format!("target {} {} {} {h}\n", t.x, t.y, t.z);
}
text += &format!("damage {}\n", self.sim.damage);
text += &format!("far {}\n", self.far);
text += &format!("effects {} {}\n", self.sim.shader, self.hd);
for (kind, roles) in &self.sim.roles {
text += &format!("roles {} {}\n", kind.key(), roles);
}
if let Err(e) = storage::set(&self.state_key(), text.as_bytes()) {
horizon_mod_sdk::warn(&format!("could not save: {e}"));
}
self.dirty = false;
}
fn load(&mut self) {
self.load_from(&self.state_key());
}
fn load_from(&mut self, key: &str) {
let Some(bytes) = storage::get(key) else { return };
let text = String::from_utf8_lossy(&bytes);
for line in text.lines() {
let w: Vec<&str> = line.split_whitespace().collect();
let num = |i: usize| w.get(i).and_then(|v| v.parse::<f64>().ok());
match w.first() {
Some(&"sam") => {
if let (Some(kind), Some(x), Some(y), Some(z), Some(h)) =
(w.get(1).and_then(|k| SamKind::from_key(k)), num(2), num(3), num(4), num(5))
{
let id = self.sim.id();
let mut sam = Sam::new(id, kind, DVec3::new(x, y, z), h);
if let Some(r) = w.get(6).and_then(|v| v.parse().ok()) {
sam.roles = r;
}
if let Some(h) = num(7) {
sam.health = h.clamp(0.0, 1.0);
}
if let Some(c) = num(8) {
sam.cargo = c as u32;
}
// Older saves have no ammunition: full, as before.
if let (Some(m), Some(b)) = (num(9), num(10)) {
sam.missiles = (m as u32).min(sam.missiles);
sam.bursts = (b as u32).min(sam.bursts);
sam.empty = num(11) == Some(1.0);
sam.reloading = num(12).map_or(0, |r| r as u32);
}
let dest = match (num(13), num(14), num(15)) {
(Some(x), Some(y), Some(z)) => Some(DVec3::new(x, y, z)),
_ => None,
};
self.sim.sams.push(sam);
if let Some(to) = dest {
let i = self.sim.sams.len() - 1;
self.sim.order_move(i, to);
}
}
}
Some(&"target") => {
if let (Some(x), Some(y), Some(z)) = (num(1), num(2), num(3)) {
self.sim.targets.push(DVec3::new(x, y, z));
self.sim.target_health.push(num(4).unwrap_or(100.0));
}
}
Some(&"damage") => self.sim.damage = w.get(1) != Some(&"false"),
Some(&"far") => self.far = w.get(1) != Some(&"false"),
Some(&"effects") => {
let shader = w.get(1) != Some(&"false");
let hd = w.get(2) == Some(&"true");
self.set_effects(shader, hd);
}
Some(&"roles") => {
if let (Some(kind), Some(r)) = (w.get(1).and_then(|k| SamKind::from_key(k)), w.get(2).and_then(|v| v.parse().ok())) {
self.sim.roles.insert(kind, r);
}
}
_ => {}
}
}
}
fn give(&self) {
// run-quiet: command.run takes at most 8 lines a call.
let lines: Vec<String> = ITEMS.iter().map(|item| format!("give @s {item}")).collect();
command::run_quiet(&lines);
say(&format!("Выдано пультов: {}", ITEMS.len()));
}
}
impl AirDef {
/// The EW stations: on if none is, else off.
fn toggle_ew(&mut self) {
let on = !self.sim.ew_active();
let (n, hot) = self.sim.set_ew(on);
if !self.sim.sams.iter().any(|s| s.kind == SamKind::Ew && s.alive()) {
say("Нет станций РЭБ: поставьте их пультом");
} else if on {
say(&format!("РЭБ включён: станций {n}{}", if hot > 0 { format!(", остывают {hot}") } else { String::new() }));
} else {
say("РЭБ выключен");
}
}
/// Where the open world's state is kept: a key of its own per world.
fn state_key(&self) -> String {
match self.world.as_ref().and_then(|w| w.as_ref()) {
Some(w) => {
// FNV-1a: storage keys are short, lowercase and plain.
let h = w.bytes().fold(0xcbf2_9ce4_8422_2325u64, |h, b| (h ^ b as u64).wrapping_mul(0x100_0000_01b3));
format!("state-{h:016x}")
}
None => "state".into(),
}
}
/// Another world opened: the last one's state saved, a clean simulation with this one's loaded.
fn open_world(&mut self, world: Option<String>) {
if self.world.is_some() && self.dirty {
self.save();
}
if self.replay.is_some() {
self.stop_replay();
}
let shader = self.sim.shader;
let seed = game::get_clock().map_or(0x5eed, |c| c.game_time.wrapping_mul(2654435761) ^ 0x9e37);
self.sim = Sim::new(seed);
self.sim.shader = shader;
self.ground = Ground::default();
self.monitor = None;
self.grid = false;
self.grid_ids.clear();
self.far = true;
self.world = Some(world);
self.load();
self.apply_far();
self.dirty = false;
self.health_mark = 0;
}
/// Distant terrain (48 chunks, coarse) while `far` is on: the raid's whole area has land,
/// in the world and in the cameras.
fn apply_far(&self) {
let far = self.far.then_some(render::FarTerrain { distance: 48, reduced: true });
render::set_far_terrain(far);
}
/// Plays the last recorded raid: "map", "full", "reel" or (with `event`) a clip.
fn start_replay(&mut self, what: &str, event: Option<usize>) -> Result<(), String> {
let n = self.sim.replays.len();
if n == 0 {
return Err("Повторов пока нет: запишется первый же налёт (когда небо очистится)".into());
}
let rec = &self.sim.replays[n - 1];
let mode = match (what, event) {
(_, Some(i)) if i < rec.events.len() => replay::Player::event_clip(rec, i),
("full", _) => replay::Mode::Full,
("reel", _) => {
let list = replay::reel(rec);
if list.is_empty() {
return Err("В этом налёте нечего показать".into());
}
replay::Mode::Clips { list, at: 0, reel: true }
}
_ => replay::Mode::Map,
};
self.replay = Some(replay::Player::new(n - 1, mode, &self.sim));
self.grid = false;
input::claim_wheel(true);
Ok(())
}
fn stop_replay(&mut self) {
self.replay = None;
input::claim_wheel(false);
render::set_hud(&[]);
render::set_views(&[]);
self.monitor_shown = false;
}
/// What a raid strikes: the marked objects, else where the player stands.
fn objects(&self, player: DVec3) -> Vec<DVec3> {
let live: Vec<DVec3> = self
.sim
.targets
.iter()
.enumerate()
.filter(|(i, _)| self.sim.target_health.get(*i).is_none_or(|h| *h > 0.0))
.map(|(_, t)| *t)
.collect();
if live.is_empty() { vec![player] } else { live }
}
fn launch_wave(&mut self, out: &mut Out) -> Result<(), String> {
let p = player().ok_or("Нет игрока")?;
if self.wave.total() == 0 {
return Err("Налёт пуст: выберите типы и число".into());
}
let objects = self.objects(DVec3::new(p.x, p.y, p.z));
self.sim.order_raid(&self.wave.order(), &objects, out);
Ok(())
}
/// The systems the grid shows: the busiest (firing, locking, hit, burning) first, the
/// monitored one always; those shown keep a head start, so the grid doesn't flicker.
fn pick_grid(&mut self) {
let shown = &self.grid_ids;
// Units that shoot, and the radars; depots, trucks and lights have nothing to show.
let mut scored: Vec<(f64, u32)> = self
.sim
.sams
.iter()
.enumerate()
.filter(|(_, s)| s.kind.armed() || s.kind == SamKind::Radar)
.map(|(i, s)| {
let busy = if self.sim.showing_kill(s) { 98.0 } else { match s.state {
sim::SamState::Launch | sim::SamState::Fire => 100.0,
sim::SamState::Lock => 85.0,
sim::SamState::Slew => 75.0,
sim::SamState::Track => 65.0,
sim::SamState::Reload => 30.0,
sim::SamState::Search => 10.0,
sim::SamState::Hold => 5.0,
sim::SamState::Destroyed => if s.burning() { 90.0 } else { 1.0 },
sim::SamState::Waiting => 35.0,
sim::SamState::Packing | sim::SamState::Moving | sim::SamState::Deploying => 40.0,
} };
let near = self.sim.watched(s).map_or(0.0, |d| 15.0 * (1.0 - (d.pos.distance(s.pos) / s.kind.range()).min(1.0)));
let hurt = if s.alive() && s.health < 0.7 { 15.0 } else { 0.0 };
let keep = if shown.contains(&s.id) { 12.0 } else { 0.0 };
let pinned = if self.monitor == Some(i) { 1000.0 } else { 0.0 };
(busy + near + hurt + keep + pinned + s.seen.len().min(5) as f64, s.id)
})
.collect();
scored.sort_by(|a, b| b.0.total_cmp(&a.0));
let mut ids: Vec<u32> = scored.iter().take(8).map(|s| s.1).collect();
// Shown in the order they were deployed, so a cell stays put while it stays chosen.
ids.sort_by_key(|id| self.sim.sams.iter().position(|s| s.id == *id));
self.grid_ids = ids;
}
fn cycle_monitor(&mut self) {
self.monitor = match self.monitor {
None if !self.sim.sams.is_empty() => Some(0),
Some(i) if i + 1 < self.sim.sams.len() => Some(i + 1),
_ => None,
};
}
fn open_menu(&mut self, page: Page) {
self.menu = Some(page);
let onoff = |b: bool| if b { "вкл" } else { "выкл" };
let mut widgets = Vec::new();
let title;
match page {
Page::Main => {
title = "AirDef — командный пункт (N меню, K монитор)".to_string();
let rows = SamKind::ARMED
.iter()
.map(|k| {
let n = self.sim.sams.iter().filter(|s| s.kind == *k).count();
let r = self.sim.roles.get(k).copied().unwrap_or(k.spec().roles);
format!("{} [{}] · развёрнуто: {n}", k.name(), sim::roles_text(r))
})
.collect();
widgets.push(Widget::List(ListWidget { id: MENU_KINDS, rows, selected: None }));
let _ = &self.monitor;
widgets.push(Widget::Button(ButtonWidget { id: BTN_GRID, label: "Командный пункт: все комплексы (J)".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_WAVE, label: "Налёт: состав и запуск…".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_REPLAYS, label: "Повторы…".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_MORE, label: "Огонь, ремонт, эффекты…".into() }));
}
Page::Replays => {
match self.sim.replays.last() {
Some(rec) => {
let kills = rec.events.iter().filter(|e| matches!(e.kind, sim::record::EventKind::Kill { .. })).count();
title = format!("Налёт №{}: {} событий, сбито {kills} — клик: повтор момента", rec.number, rec.events.len());
let rows = (0..rec.events.len().min(200)).map(|i| replay::row(rec, i)).collect();
widgets.push(Widget::List(ListWidget { id: REPLAY_EVENTS, rows, selected: None }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_MAP, label: "Карта налёта (R)".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_FULL, label: "Полный повтор".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_REEL, label: format!("Лучшие моменты ({})", replay::reel(rec).len()) }));
}
None => {
title = "Повторы".into();
widgets.push(Widget::Text(horizon_mod_sdk::ui::TextWidget {
id: 0,
text: "Повторов пока нет: налёт записывается сам и появится здесь, когда небо очистится".into(),
color: 0,
}));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
}
}
}
Page::More => {
title = "AirDef — управление".to_string();
widgets.push(Widget::Button(ButtonWidget {
id: BTN_HOLD,
label: format!("Огонь ПВО: {}", if self.sim.hold { "запрещён" } else { "разрешён" }),
}));
let broken = self.sim.sams.iter().filter(|s| s.health < 1.0).count();
widgets.push(Widget::Button(ButtonWidget { id: BTN_REPAIR, label: format!("Ремонт всех (повреждено: {broken})") }));
let fx = if !self.sim.shader { "выкл" } else if self.hd { "HD (свет, bloom)" } else { "обычные" };
widgets.push(Widget::Button(ButtonWidget { id: BTN_SHADER, label: format!("Эффекты: {fx}") }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_DAMAGE, label: format!("Разрушения: {}", onoff(self.sim.damage)) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_FAR, label: format!("Дальний ландшафт: {}", onoff(self.far)) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
}
Page::Wave => {
let w = &self.wave;
title = format!("Налёт: {} целей — клик по строке меняет число", w.total());
let rows = wave::KINDS
.iter()
.zip(w.counts)
.map(|(k, n)| format!("{} — {}", k.spec().name, if n == 0 { "нет".to_string() } else { n.to_string() }))
.collect();
widgets.push(Widget::List(ListWidget { id: WAVE_KINDS, rows, selected: None }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_NEXT, label: "Параметры и пуск →".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
}
Page::WaveGo => {
let w = &self.wave;
title = format!("Налёт: {} целей", w.total());
widgets.push(Widget::Button(ButtonWidget { id: BTN_PRESET, label: format!("Готовый: {}", wave::PRESETS[w.preset].name) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_APPROACH, label: format!("Откуда: {}", w.approach.name()) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_DIST, label: format!("Старт: {}", panel::distance(w.dist)) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_AIM, label: format!("Цели: {}", w.aim.name()) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_LAUNCH, label: format!("▶ ПУСК ({})", w.total()) }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Состав".into() }));
}
Page::Roles(kind) => {
title = format!("{} ({}) — по каким целям стрелять", kind.name(), panel::distance(kind.range()));
let _ = ItemWidget { id: 0, item: String::new(), name: String::new() };
let roles = self.sim.roles.get(&kind).copied().unwrap_or(kind.spec().roles);
for (i, c) in Class::ALL.iter().enumerate() {
let on = roles & c.bit() != 0;
widgets.push(Widget::Button(ButtonWidget {
id: BTN_CLASS + i as u32,
label: format!("{} {}", if on { "[ВКЛ]" } else { "[ — ]" }, c.name()),
}));
}
widgets.push(Widget::Button(ButtonWidget { id: BTN_DEFAULT, label: "Сбросить по умолчанию".into() }));
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
}
}
ui::open_screen(&Screen { title, widgets });
}
fn set_roles(&mut self, kind: SamKind, mask: Option<u8>) {
let mask = match mask {
Some(m) => {
self.sim.roles.insert(kind, m);
m
}
None => {
self.sim.roles.remove(&kind);
kind.spec().roles
}
};
for s in self.sim.sams.iter_mut().filter(|s| s.kind == kind) {
s.roles = mask;
s.target = None;
s.gun_target = None;
}
self.dirty = true;
}
}
const HELP: &str = "/airdef menu | monitor | grid | replay [map|full|reel|stop] | raid | repair | import | ew on|off | flare | move <номер> | target here | give | deploy <комплекс> | wave <тип|mix> [кол-во] [дальность] | clear | targets clear | damage on|off | shader on|off|hd | hold on|off | roles [комплекс классы] | stats";
impl Mod for AirDef {
fn init() -> Result<(Self, Registration), String> {
let seed = game::get_clock().map_or(0x5eed, |c| c.game_time.wrapping_mul(2654435761) ^ 0x9e37);
let mut me = AirDef {
sim: Sim::new(seed),
ground: Ground::default(),
dirty: false,
hud_shown: false,
monitor: None,
monitor_shown: false,
grid: false,
grid_ids: Vec::new(),
wave: wave::WaveConfig::default(),
replay: None,
far: true,
moving: None,
hd: false,
world: None,
health_mark: 0,
menu: None,
listener: DVec3::ZERO,
pending: Vec::new(),
};
let _ = input::register_key("menu", "Меню AirDef", "key.keyboard.n");
let _ = input::register_key("monitor", "Монитор ПВО: следующий комплекс", "key.keyboard.k");
let _ = input::register_key("grid", "Командный пункт: все комплексы", "key.keyboard.j");
let _ = input::register_key("replay", "Повтор налёта: карта / выход", "key.keyboard.r");
let _ = input::register_key("ew", "РЭБ: включить / выключить", "key.keyboard.u");
// The replay's own keys (they do nothing outside a replay).
let _ = input::register_key("rp_back", "Повтор: назад", "key.keyboard.left");
let _ = input::register_key("rp_forward", "Повтор: вперёд", "key.keyboard.right");
let _ = input::register_key("rp_faster", "Повтор: быстрее", "key.keyboard.up");
let _ = input::register_key("rp_slower", "Повтор: медленнее", "key.keyboard.down");
// Not Enter: it opens the chat.
let _ = input::register_key("rp_pause", "Повтор: пауза", "key.keyboard.space");
let _ = input::register_key("rp_exit", "Повтор: выход", "key.keyboard.backspace");
input::claim_items(&ITEMS.map(String::from));
render::set_post(include_str!("../shaders/effects.wgsl"));
me.sim.shader = true;
me.apply_far();
Ok((me, Registration::new().command("airdef").on_tick()))
}
fn tick(&mut self, _tick: u64) {
let Some(p) = player() else { return };
// Each world keeps its own systems, objects and settings: loaded when it opens.
let world = game::world_id();
if self.world.as_ref() != Some(&world) {
self.open_world(world);
}
for event in input::poll() {
match event {
Event::UseStart(u) => self.use_item(&u.item.id),
Event::KeyDown(k) if k == "menu" => {
if self.replay.is_some() {
self.stop_replay();
}
self.open_menu(Page::Main)
}
Event::KeyDown(k) if k == "rp_exit" && self.replay.is_some() => self.stop_replay(),
Event::KeyDown(k) if k.starts_with("rp_") => {
let c = match k.as_str() {
"rp_back" => replay::Control::Back,
"rp_forward" => replay::Control::Forward,
"rp_faster" => replay::Control::Faster,
"rp_slower" => replay::Control::Slower,
_ => replay::Control::Pause,
};
if let Some(r) = &mut self.replay
&& let Some(rec) = self.sim.replays.get(r.rec)
{
r.control(c, rec);
}
}
Event::KeyDown(k) if k == "monitor" => self.cycle_monitor(),
Event::KeyDown(k) if k == "grid" => self.grid = !self.grid,
Event::KeyDown(k) if k == "ew" => self.toggle_ew(),
Event::KeyDown(k) if k == "replay" => {
if self.replay.is_some() {
self.stop_replay();
} else if let Err(e) = self.start_replay("map", None) {
say(&e);
}
}
Event::Wheel(w) => {
if let Some(r) = &mut self.replay
&& let Some(rec) = self.sim.replays.get(r.rec)
{
r.wheel(w, rec);
}
}
_ => {}
}
}
let now = self.sim.tick;
self.ground.answer(render::ground(), now);
let mut out = Out::default();
self.listener = DVec3::new(p.x, p.y + 1.6, p.z);
self.sim.night = game::get_clock().is_some_and(|c| (13000..23000).contains(&(c.day_time % 24000)));
self.sim.step(&mut self.ground, Some(DVec3::new(p.x, p.y, p.z)), &mut out);
let wanted = self.ground.take_wanted();
if !wanted.is_empty() {
render::query_ground(&wanted);
}
if let Some(mut r) = self.replay.take() {
r.tick(&self.sim, self.listener, &mut out);
if r.done {
self.replay = Some(r);
self.stop_replay();
} else {
self.replay = Some(r);
}
}
self.emit(out);
self.draw_hud(DVec3::new(p.x, p.y, p.z), p.yaw);
// The replay takes the screen; else the monitors and the cameras they show.
if let Some(r) = &self.replay {
let size = render::gui_size();
render::set_hud(&r.hud(&self.sim, size));
render::set_views(&r.views(size));
self.monitor_shown = true;
} else if self.grid {
let stale = self.grid_ids.iter().any(|id| !self.sim.sams.iter().any(|s| s.id == *id));
if self.sim.tick % 40 == 0 || stale || self.grid_ids.len() < self.sim.sams.len().min(8) {
self.pick_grid();
}
let picked: Vec<usize> =
self.grid_ids.iter().filter_map(|id| self.sim.sams.iter().position(|s| s.id == *id)).collect();
render::set_hud(&monitor::grid(&self.sim, &picked, render::gui_size()));
let views: Vec<_> = picked.iter().map(|&i| monitor::camera(&self.sim, &self.sim.sams[i])).collect();
render::set_views(&views);
self.monitor_shown = true;
} else {
match self.monitor {
Some(i) if i < self.sim.sams.len() => {
render::set_hud(&monitor::draw(&self.sim, i));
render::set_views(&[monitor::camera(&self.sim, &self.sim.sams[i])]);
self.monitor_shown = true;
}
_ => {
if self.monitor_shown {
render::set_hud(&[]);
render::set_views(&[]);
self.monitor_shown = false;
}
}
}
}
// Damage is saved too: a destroyed system stays destroyed. So are where the units stand
// (or drive to: not every step of the way), their ammunition and the depots' stock.
let mark = self
.sim
.sams
.iter()
.map(|s| {
let at = s.dest.unwrap_or(s.pos);
let place = (at.x * 10.0) as i64 as u64 ^ ((at.z * 10.0) as i64 as u64).rotate_left(21) ^ (if s.dest.is_some() { 0 } else { (s.heading * 100.0) as i64 as u64 }).rotate_left(42);
let ammo = u64::from(s.missiles) | u64::from(s.bursts) << 16 | u64::from(s.cargo) << 32 | u64::from(s.empty) << 48 | u64::from(s.reloading > 0) << 49;
((s.health * 1000.0) as u64).wrapping_mul(1_000_003) ^ place ^ ammo.rotate_left(7)
})
.chain(self.sim.target_health.iter().map(|h| (h * 10.0) as u64))
.fold(self.sim.sams.len() as u64, |a, h| a.wrapping_mul(31).wrapping_add(h));
if mark != self.health_mark {
self.health_mark = mark;
self.dirty = true;
}
if self.dirty {
self.save();
}
}
fn ui_select(&mut self, id: u32, row: u32) {
let page = self.menu.unwrap_or(Page::Main);
match (page, id) {
(Page::Main, MENU_KINDS) => {
if let Some(k) = SamKind::ARMED.get(row as usize) {
self.open_menu(Page::Roles(*k));
}
return;
}
(Page::More, BTN_HOLD) => self.sim.hold = !self.sim.hold,
(Page::Main, BTN_MONITOR) => self.cycle_monitor(),
(Page::Main, BTN_WAVE) => {
self.open_menu(Page::Wave);
return;
}
(Page::More, BTN_REPAIR) => {
self.sim.repair();
self.dirty = true;
}
(Page::Wave, WAVE_KINDS) => {
if (row as usize) < wave::KINDS.len() {
self.wave.step(row as usize);
}
}
(Page::WaveGo, BTN_PRESET) => {
let next = self.wave.preset + 1;
self.wave.apply(next);
}
(Page::WaveGo, BTN_APPROACH) => {
let all = sim::Approach::ALL;
let i = all.iter().position(|a| *a == self.wave.approach).unwrap_or(0);
self.wave.approach = all[(i + 1) % all.len()];
}
(Page::WaveGo, BTN_DIST) => {
let all = wave::DISTANCES;
let i = all.iter().position(|d| *d == self.wave.dist).unwrap_or(0);
self.wave.dist = all[(i + 1) % all.len()];
}
(Page::WaveGo, BTN_AIM) => {
let all = sim::Aim::ALL;
let i = all.iter().position(|a| *a == self.wave.aim).unwrap_or(0);
self.wave.aim = all[(i + 1) % all.len()];
}
(Page::WaveGo, BTN_LAUNCH) => {
let mut out = Out::default();
match self.launch_wave(&mut out) {
Ok(()) => {
self.emit(out);
self.menu = None;
ui::close_screen();
return;
}
Err(e) => say(&e),
}
}
(Page::Wave, BTN_BACK) | (Page::More, BTN_BACK) => {
self.open_menu(Page::Main);
return;
}
(Page::Wave, BTN_NEXT) => {
self.open_menu(Page::WaveGo);
return;
}
(Page::WaveGo, BTN_BACK) => {
self.open_menu(Page::Wave);
return;
}
(Page::Main, BTN_REPLAYS) => {
self.open_menu(Page::Replays);
return;
}
(Page::Replays, REPLAY_EVENTS | BTN_MAP | BTN_FULL | BTN_REEL) => {
let r = match id {
REPLAY_EVENTS => self.start_replay("clip", Some(row as usize)),
BTN_FULL => self.start_replay("full", None),
BTN_REEL => self.start_replay("reel", None),
_ => self.start_replay("map", None),
};
match r {
Ok(()) => {
self.menu = None;
ui::close_screen();
}
Err(e) => say(&e),
}
return;
}
(Page::Replays, BTN_BACK) => {
self.open_menu(Page::Main);
return;
}
(Page::Main, BTN_MORE) => {
self.open_menu(Page::More);
return;
}
(Page::Main, BTN_GRID) => {
self.grid = true;
self.menu = None;
ui::close_screen();
return;
}
(Page::More, BTN_SHADER) => {
// Off → effects → HD → off.
let (shader, hd) = match (self.sim.shader, self.hd) {
(false, _) => (true, false),
(true, false) => (true, true),
(true, true) => (false, false),
};
self.set_effects(shader, hd);
}
(Page::More, BTN_FAR) => {
self.far = !self.far;
self.apply_far();
self.dirty = true;
}
(Page::More, BTN_DAMAGE) => {
self.sim.damage = !self.sim.damage;
self.dirty = true;
}
(Page::Roles(kind), b) if (BTN_CLASS..BTN_CLASS + 5).contains(&b) => {
let roles = self.sim.roles.get(&kind).copied().unwrap_or(kind.spec().roles);
self.set_roles(kind, Some(roles ^ Class::ALL[(b - BTN_CLASS) as usize].bit()));
}
(Page::Roles(kind), BTN_ALL) => self.set_roles(kind, Some(0x1F)),
(Page::Roles(kind), BTN_DEFAULT) => self.set_roles(kind, None),
(Page::Roles(kind), BTN_NONE) => self.set_roles(kind, Some(0)),
(Page::Roles(_), BTN_BACK) => {
self.open_menu(Page::Main);
return;
}
_ => return,
}
self.open_menu(page);
}
fn ui_closed(&mut self) {
self.menu = None;
}
fn command(&mut self, _name: &str, args: &str) -> Result<Option<String>, String> {
let w: Vec<&str> = args.split_whitespace().collect();
let mut out = Out::default();
let reply = match w.as_slice() {
["menu"] => {
self.open_menu(Page::Main);
None
}
["monitor"] => {
self.cycle_monitor();
None
}
["grid"] => {
self.grid = !self.grid;
None
}
["give"] => {
self.give();
None
}
["deploy", kind] => {
// A system where the player stands, a few blocks ahead.
let kind = SamKind::from_key(kind)
.ok_or("Техника: patriot, gepard, pantsir, s400, s500, irist, nasams, buk, tor, p1sun, radar, depot, tzm, ew, light")?;
let p = player().ok_or("Нет игрока")?;
let d = view(&p);
let flat = DVec3::new(d.x, 0.0, d.z).normalize_or(DVec3::NEG_Z);
let at = DVec3::new(p.x, p.y, p.z) + flat * 8.0;
let sid = self.sim.id();
let mut sam = Sam::new(sid, kind, at, (-flat.x).atan2(-flat.z));
if let Some(r) = self.sim.roles.get(&kind) {
sam.roles = *r;
}
self.sim.sams.push(sam);
self.dirty = true;
Some(format!("{} развёрнут", kind.name()))
}
["wave", kind, rest @ ..] => {
let count = rest.first().and_then(|v| v.parse().ok()).unwrap_or(5u32).clamp(1, 80);
let dist = rest.get(1).and_then(|v| v.parse().ok()).unwrap_or(260.0f64).clamp(60.0, 800.0);
let p = player().ok_or("Нет игрока")?;
let target = self
.sim
.nearest_target(DVec3::new(p.x, p.y, p.z))
.unwrap_or(DVec3::new(p.x, p.y, p.z));
if *kind == "mix" {
let objects = self.objects(DVec3::new(p.x, p.y, p.z));
self.sim.order_raid(&wave::WaveConfig::mix(count, dist), &objects, &mut out);
} else {
let kind = DroneKind::from_key(kind).ok_or(
"Тип: shahed, geran3, lancet, gerbera, kh101, kalibr, kh22, zircon, iskander, kinzhal, oreshnik или mix",
)?;
self.sim.raid(kind, target, count, dist, &mut out);
}
None
}
["replay", rest @ ..] => {
match rest.first().copied().unwrap_or("map") {
"stop" => self.stop_replay(),
what => self.start_replay(what, None)?,
}
None
}
["raid"] => {
self.launch_wave(&mut out)?;
None
}
["move", n] => {
// Unit n (as the summary numbers them) drives to where the player stands.
let p = player().ok_or("Нет игрока")?;
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("/airdef move <номер>")?;
if self.sim.order_move(i, DVec3::new(p.x, p.y, p.z)) {
Some(format!("{} №{}: на марш", self.sim.sams[i].kind.name(), i + 1))
} else {
Some("Эта техника не может ехать".into())
}
}
["ew", v @ ("on" | "off")] => {
let (n, hot) = self.sim.set_ew(*v == "on");
Some(format!("РЭБ: включено станций {n}{}", if hot > 0 { format!(", остывают {hot}") } else { String::new() }))
}
["flare"] => {
let p = player().ok_or("Нет игрока")?;
self.sim.fire_flare(eye(&p) + view(&p), view(&p), &mut out);
None
}
["import"] => {
// The state the mod kept before worlds had their own: brought into this world.
let before = self.sim.sams.len();
self.load_from("state");
self.dirty = true;
Some(format!("Перенесено комплексов из старой версии: {}", self.sim.sams.len() - before))
}
["repair"] => {
let n = self.sim.repair();
self.dirty = true;
Some(format!("Отремонтировано комплексов: {n}; объекты восстановлены"))
}
["clear"] => {
self.sim.clear();
Some("Небо очищено".to_string())
}
["target", "here"] => {
let p = player().ok_or("Нет игрока")?;
self.sim.targets.push(DVec3::new(p.x, p.y, p.z));
self.sim.target_health.push(100.0);
self.dirty = true;
Some(format!("Объект №{} отмечен здесь", self.sim.targets.len()))
}
["targets", "clear"] => {
self.sim.targets.clear();
self.sim.target_health.clear();
self.dirty = true;
Some("Цели убраны".to_string())
}
["damage", v @ ("on" | "off")] => {
self.sim.damage = *v == "on";
self.dirty = true;
Some(format!("Разрушения: {}", if self.sim.damage { "вкл" } else { "выкл" }))
}
["roles"] => {
for kind in SamKind::ARMED {
let r = self.sim.roles.get(&kind).copied().unwrap_or(kind.spec().roles);
let names: Vec<&str> = Class::ALL.iter().filter(|c| r & c.bit() != 0).map(|c| c.name()).collect();
say(&format!("{}: {}", kind.name(), if names.is_empty() { "ничего".into() } else { names.join(", ") }));
}
Some("Классы: drone, jet, cruise, supersonic, ballistic (или all). /airdef roles <комплекс|all> <классы|default>".into())
}
["roles", who, what] => {
let kinds: Vec<SamKind> = if *who == "all" {
SamKind::ARMED.to_vec()
} else {
vec![SamKind::from_key(who).ok_or("Комплекс: patriot, gepard, pantsir, s400, s500, irist, nasams, buk, tor, p1sun или all")?]
};
for kind in kinds {
let mask = if *what == "default" {
self.sim.roles.remove(&kind);
kind.spec().roles
} else {
let m = sim::parse_roles(what).ok_or("Классы через запятую: drone,jet,cruise,supersonic,ballistic или all")?;
self.sim.roles.insert(kind, m);
m
};
for s in self.sim.sams.iter_mut().filter(|s| s.kind == kind) {
s.roles = mask;
s.target = None;
s.gun_target = None;
}
}
self.dirty = true;
Some("Роли ПВО обновлены".into())
}
["hold", v @ ("on" | "off")] => {
self.sim.hold = *v == "on";
Some(if self.sim.hold { "ПВО: огонь запрещён".into() } else { "ПВО: огонь разрешён".into() })
}
["shader", v @ ("on" | "off" | "hd")] => {
self.set_effects(*v != "off", *v == "hd");
Some(format!("Эффекты: {}", match *v { "off" => "выкл", "hd" => "HD", _ => "обычные" }))
}
["stats"] => Some(format!(
"В воздухе: {}, ракет: {}, ПВО: {}, сбито: {}, поражений: {}",
self.sim.drones.iter().filter(|d| d.alive()).count(),
self.sim.missiles.len(),
self.sim.sams.len(),
self.sim.kills,
self.sim.hits
)),
_ => return Err(HELP.to_string()),
};
self.emit(out);
Ok(reply)
}
}
horizon_mod_sdk::export_mod!(AirDef);