375fdf2d80
Co-Authored-By: Codex <noreply@openai.com>
2867 lines
132 KiB
Rust
2867 lines
132 KiB
Rust
//! 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, ModelInstanceId, ParticleSpawn, PointLight, SpotLight},
|
||
storage,
|
||
ui::{self, ButtonWidget, ItemWidget, ListWidget, Screen, Widget},
|
||
};
|
||
|
||
mod battery_view;
|
||
mod cinema;
|
||
mod capabilities;
|
||
mod engines;
|
||
mod commands;
|
||
mod layout;
|
||
mod map;
|
||
mod film;
|
||
mod monitor;
|
||
mod panel;
|
||
mod presentation;
|
||
mod radar;
|
||
mod replay;
|
||
mod scene;
|
||
mod smoke;
|
||
pub use airdef_core::sim;
|
||
mod scenario;
|
||
mod wave;
|
||
use sim::{Class, DroneKind, Ground, Out, Sam, SamKind, Sim};
|
||
|
||
const ITEMS: [&str; sim::catalog::INVENTORY_COUNT] = sim::catalog::INVENTORY;
|
||
|
||
struct AirDef {
|
||
smoke: smoke::Smoke,
|
||
sim: Sim,
|
||
ground: Ground,
|
||
dirty: bool,
|
||
/// Wall-clock-free pacing of autosaves: the tick before which none is written (at most one a
|
||
/// second while guns fire, and a pause after a failed write).
|
||
next_save: u64,
|
||
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,
|
||
/// Playback lifecycle. Export owns the exact replay player it is capturing.
|
||
presentation: presentation::Session<replay::Player, Export>,
|
||
/// The effects preset a film replaced: (shader, hd).
|
||
film_prev: Option<(bool, bool)>,
|
||
/// The world drawn beyond the render distance (replays and cameras see far off).
|
||
far: bool,
|
||
/// The acoustics asked for, until the game has them (its answer comes a tick later).
|
||
acoustics: Option<bool>,
|
||
/// The game's log of block changes (`render.world-log-start`): a replay shows the world as
|
||
/// it was at its moment, not the holes the raid left (None where the game has no such log).
|
||
block_log: Option<u32>,
|
||
/// A replay's time view was set (so it is cleared when the replay ends).
|
||
time_view: 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 durable systems, objects and strike stock as last saved, to save again when they change.
|
||
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,
|
||
/// The picture punch (#51) the HD exposure and bloom were last set for.
|
||
punch: f32,
|
||
/// Sounds on their way to the player at the speed of sound.
|
||
pending: Vec<PendingSound>,
|
||
/// The engines as persistent sound sources (#95), and the source generation they were started under.
|
||
engines: engines::Engines,
|
||
engine_gen: u32,
|
||
/// Whether the engines are a replay's (a change of mode cuts them).
|
||
engines_replay: bool,
|
||
/// The handles `render.model-id` gave the model names (valid under `model_generation`); none:
|
||
/// a name the game doesn't know.
|
||
model_ids: std::collections::HashMap<&'static str, Option<u32>>,
|
||
model_generation: u32,
|
||
/// The instances handed to the game, kept between ticks so nothing is allocated for them.
|
||
by_id: Vec<ModelInstanceId>,
|
||
/// The command map (#48).
|
||
map: map::MapUi,
|
||
}
|
||
|
||
/// What `/airdef replay export` was asked for.
|
||
struct ExportOpts {
|
||
name: String,
|
||
which: String,
|
||
fps: u32,
|
||
size: (u32, u32),
|
||
crf: u32,
|
||
audio: bool,
|
||
seconds: Option<f64>,
|
||
}
|
||
#[derive(PartialEq)]
|
||
enum Stage {
|
||
Planning,
|
||
Arming,
|
||
Recording,
|
||
Finishing,
|
||
}
|
||
struct Export {
|
||
/// The presentation generation whose film this export records.
|
||
generation: u64,
|
||
opts: ExportOpts,
|
||
stage: Stage,
|
||
ticks: u32,
|
||
}
|
||
|
||
/// Whether a replay or film may be started now: not while an export records (stop it first).
|
||
fn switch_allowed(exporting: bool) -> Result<(), String> {
|
||
if exporting {
|
||
Err("Экспорт идёт: дождитесь конца или /airdef replay stop".into())
|
||
} else {
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
/// An engine voice as a `render.sound-sources` entry.
|
||
fn source_op(kind: render::SourceOpKind, id: u32, v: &engines::Voice) -> render::SourceOp {
|
||
render::SourceOp {
|
||
kind,
|
||
id,
|
||
event: v.event.to_string(),
|
||
x: v.at.x,
|
||
y: v.at.y,
|
||
z: v.at.z,
|
||
vx: v.vel.x as f32,
|
||
vy: v.vel.y as f32,
|
||
vz: v.vel.z as f32,
|
||
gain: v.gain,
|
||
pitch: v.pitch,
|
||
looping: true,
|
||
priority: 1.0,
|
||
attack: v.attack,
|
||
release: v.release,
|
||
doppler: engines::DOPPLER,
|
||
loop_from: v.loop_from,
|
||
loop_to: v.loop_to,
|
||
}
|
||
}
|
||
|
||
/// A sound heard later: when, what, where, and how loud and high it was.
|
||
struct PendingSound {
|
||
due: f64,
|
||
generation: u64,
|
||
created_at: presentation::Clock,
|
||
name: String,
|
||
at: DVec3,
|
||
volume: f32,
|
||
pitch: f32,
|
||
}
|
||
|
||
impl PendingSound {
|
||
fn invalidated_by(&self, generation: u64, clock: presentation::Clock) -> bool {
|
||
self.generation != generation
|
||
|| !self.created_at.same_domain(clock)
|
||
|| clock.value() < self.created_at.value()
|
||
}
|
||
}
|
||
|
||
/// 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;
|
||
/// The same when the game's acoustics muffle (its tracing reaches 512 blocks).
|
||
const ACOUSTIC_FAR: f64 = 480.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,
|
||
BatteryDeploy,
|
||
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,
|
||
/// The systems with their doctrines, and one system's doctrine (by id) (#47).
|
||
Fleet,
|
||
Doctrine(u32),
|
||
}
|
||
|
||
const MENU_KINDS: u32 = 1;
|
||
const BATTERY_ROWS: u32 = 5;
|
||
const BTN_BATTERY: u32 = 22;
|
||
const BATTERY_DEPLOY: [(&str, &str); 5] = [
|
||
("s400_launcher", "С-400 — отдельная пусковая"),
|
||
("s500_launcher", "С-500 — отдельная пусковая"),
|
||
("radar_search", "РЛС обзора"),
|
||
("radar_track", "РЛС сопровождения"),
|
||
("radar_height", "Мачтовая РЛС"),
|
||
];
|
||
|
||
fn deploy_configuration(key: &str) -> Option<(SamKind, sim::battery::SamMode, sim::battery::RadarRole)> {
|
||
use sim::battery::{RadarRole as R, SamMode as M};
|
||
Some(match key {
|
||
"s400_launcher" => (SamKind::S400, M::LauncherOnly, R::Multifunction),
|
||
"s500_launcher" => (SamKind::S500, M::LauncherOnly, R::Multifunction),
|
||
"radar_search" => (SamKind::Radar, M::Integrated, R::Search),
|
||
"radar_track" => (SamKind::Radar, M::Integrated, R::Engagement),
|
||
"radar_height" => (SamKind::Radar, M::Integrated, R::Height),
|
||
_ => (SamKind::from_key(key)?, M::Integrated, R::Multifunction),
|
||
})
|
||
}
|
||
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_ACOUSTICS: u32 = 20;
|
||
const BTN_DOCTRINE: u32 = 21;
|
||
const FLEET_ROWS: u32 = 4;
|
||
const BTN_RESERVE: u32 = 50;
|
||
const BTN_SALVO: u32 = 51;
|
||
const BTN_SECTOR_DIR: u32 = 52;
|
||
const BTN_SECTOR_WIDTH: u32 = 53;
|
||
const BTN_GUARD: u32 = 54;
|
||
const BTN_DOC_RESET: u32 = 55;
|
||
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);
|
||
}
|
||
|
||
/// What the effects draw this tick (`Mod::shown`).
|
||
struct Shown {
|
||
blasts: Vec<sim::Blast>,
|
||
/// The clock the blasts' `start` is on: the simulation's ticks, or the recording's.
|
||
now: f32,
|
||
/// 1 minus the share of the frame's partial tick the effects advance with.
|
||
hold: f32,
|
||
replay: bool,
|
||
}
|
||
|
||
impl Shown {
|
||
fn from_context(ctx: &presentation::Context, scene: &scene::Snapshot<'_>) -> Self {
|
||
let recording = ctx.is_playback() && ctx.filming;
|
||
Self {
|
||
blasts: scene.blasts().into_owned(),
|
||
now: scene.time() as f32,
|
||
hold: if recording { 1.0 - ctx.rate.clamp(0.0, 1.0) } else { 0.0 },
|
||
replay: recording,
|
||
}
|
||
}
|
||
}
|
||
|
||
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 sim::catalog::launch_item(id).is_some() => {
|
||
let Some(kind) = sim::catalog::launch_item(id) 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 sim::catalog::deploy_item(id).is_some() => {
|
||
let Some(kind) = sim::catalog::deploy_item(id) 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, ctx: &presentation::Context) -> Vec<PointLight> {
|
||
let shown = self.shown(ctx);
|
||
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 = shown.now as u64;
|
||
let flicker = |id: u32| 0.85 + 0.15 * (((tick as u32).wrapping_mul(2654435761) ^ id.wrapping_mul(97)) % 100) as f32 / 100.0;
|
||
// Blasts first, the nearest first: a crowded sky never costs the key intercept its light.
|
||
let viewer = self.viewer(ctx);
|
||
let mut near: Vec<&sim::Blast> = shown.blasts.iter().collect();
|
||
if let Some(e) = viewer {
|
||
near.sort_by(|a, b| a.at.distance_squared(e).total_cmp(&b.at.distance_squared(e)));
|
||
}
|
||
for (rank, b) in near.into_iter().enumerate() {
|
||
let age = (shown.now - b.start as f32).max(0.0);
|
||
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;
|
||
// Its own id range: the models' and the systems' ids are small numbers.
|
||
let id = 0x6100_0000 | (b.id & 0x00ff_ffff);
|
||
let centre = b.at + DVec3::Y * size as f64 * 0.5;
|
||
add(id, centre, (1.0, 0.58, 0.25), size * size * 18.0 * (glow + flash), size * 14.0);
|
||
// The punch (#51): a white burst that lights the land, the smoke and the wrecks far round
|
||
// for a moment; for the nearest few, scaled by the blast.
|
||
if rank < 6 {
|
||
let burst = (-age / 2.0).exp();
|
||
add(0x6300_0000 | (b.id & 0x00ff_ffff), centre, (1.0, 0.9, 0.74), size * size * 95.0 * burst, (size * 30.0).min(256.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),
|
||
_ => {}
|
||
}
|
||
}
|
||
// A replay shows its own flames (the models of the ghosts) and none of the live world's.
|
||
if shown.replay {
|
||
return lights;
|
||
}
|
||
// Fires burn on for minutes: a flickering, wide glow that dies down with the flames.
|
||
for f in self.sim.fires.list.iter().filter(|f| f.shown) {
|
||
let (fl, sm) = f.level(tick);
|
||
if f.quiet {
|
||
continue;
|
||
}
|
||
let glow = fl.max(0.12 * sm * (1.0 - (tick.saturating_sub(f.start)) as f32 / f.life as f32));
|
||
let id = 0x6200_0000 | (f.id & 0x00ff_ffff);
|
||
add(id, f.at + DVec3::Y * 1.2, (1.0, 0.5, 0.17), 70.0 * f.size * glow * flicker(f.id), 20.0 + 10.0 * f.size);
|
||
}
|
||
let mut spotted: Vec<u32> = Vec::new();
|
||
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);
|
||
}
|
||
// Without the renderer's spot lights, a searchlight's spot where its beam meets the target.
|
||
if !self.sim.spot_hd
|
||
&& 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)
|
||
&& !spotted.contains(&t.id)
|
||
{
|
||
spotted.push(t.id);
|
||
add(s.id + 14, t.pos, (0.95, 0.97, 1.0), 220.0, 30.0);
|
||
}
|
||
}
|
||
lights
|
||
}
|
||
|
||
/// The searchlights' spot lights (HD): a cone from the head along its real direction, as far
|
||
/// as the beam runs free; at most 16, the renderer draws the nearest.
|
||
fn spots(&self, ctx: &presentation::Context) -> Vec<SpotLight> {
|
||
let shown = self.shown(ctx);
|
||
// A replay lights with the recording's searchlights, where and as they pointed.
|
||
let beams: Vec<sim::lights::Beam> = if shown.replay {
|
||
match self.presentation.playback().and_then(|r| self.sim.replay(r.rec).map(|rec| rec.beams(f64::from(shown.now)))) {
|
||
Some(b) => b,
|
||
None => Vec::new(),
|
||
}
|
||
} else {
|
||
self.sim.sams.iter().filter_map(|s| s.spot_beam()).collect()
|
||
};
|
||
beams
|
||
.into_iter()
|
||
.take(16)
|
||
.map(|b| SpotLight {
|
||
id: b.id,
|
||
x: b.origin.x,
|
||
y: b.origin.y,
|
||
z: b.origin.z,
|
||
dx: b.dir.x as f32,
|
||
dy: b.dir.y as f32,
|
||
dz: b.dir.z as f32,
|
||
color: (0.95, 0.97, 1.0),
|
||
intensity: 12_000.0,
|
||
range: (b.free + 3.5).min(1024.0) as f32,
|
||
inner_angle: sim::lights::BEAM_INNER as f32,
|
||
outer_angle: sim::lights::BEAM_OUTER as f32,
|
||
beam: 1.0,
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// Whether the game's acoustics are on, or asked to be.
|
||
fn acoustics_on(&self) -> bool {
|
||
self.acoustics.unwrap_or_else(render::acoustics)
|
||
}
|
||
|
||
/// 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();
|
||
if !self.hd {
|
||
self.sim.spot_hd = false;
|
||
}
|
||
self.dirty = true;
|
||
}
|
||
|
||
/// Switches the HD lighting.
|
||
fn apply_hd(&self) {
|
||
render::set_lighting(Lighting { hd: self.hd, exposure: 1.0, bloom: 0.55 });
|
||
// (The punch of the next blast sets its own.)
|
||
if !self.hd {
|
||
render::set_lights(&[]);
|
||
let _ = render::set_spot_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, ctx: &presentation::Context) -> Vec<f32> {
|
||
let shown = self.shown(ctx);
|
||
let mut p = vec![0.0f32; 4];
|
||
p[0] = shown.now;
|
||
p[3] = if self.smoke.hd { 2.0 } else if self.hd { 1.0 } else { 0.0 };
|
||
let mut blasts: Vec<&sim::Blast> = shown.blasts.iter().rev().take(48).collect();
|
||
// The shader composites the volumes front to back with one shared transmittance, so
|
||
// the nearest to the player goes first. This is exact for volumes that do not
|
||
// overlap; where two intersect, no order by centre is right along every ray.
|
||
if let Some(e) = self.viewer(ctx) {
|
||
blasts.sort_by(|a, b| a.at.distance_squared(e).total_cmp(&b.at.distance_squared(e)));
|
||
}
|
||
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;
|
||
// The last vec4: how much of the frame's partial tick the effects run on (0 live; a
|
||
// slowed or paused replay runs on its own time, not the frame's).
|
||
p.resize(1024, 0.0);
|
||
p[1020] = shown.hold;
|
||
p
|
||
}
|
||
|
||
/// The smoke volumes the renderer draws and the clock they are aged by: the live ones, or (in a
|
||
/// replay) the blasts' billows at the replay's moment, never the live raid's trails and fires.
|
||
/// The recorded scene is read directly; live simulation state is never replaced.
|
||
fn shown_smoke(&self, ctx: &presentation::Context) -> (f64, Vec<render::SmokeSegment>) {
|
||
let scene = self.scene_snapshot(ctx);
|
||
(scene.time(), self.smoke.segments(&scene))
|
||
}
|
||
|
||
/// Where the picture is seen from: the replay's camera, or the player's eyes.
|
||
fn viewer(&self, ctx: &presentation::Context) -> Option<DVec3> {
|
||
if ctx.is_playback() && ctx.filming {
|
||
self.presentation.playback().map(|r| r.eye())
|
||
} else {
|
||
Some(ctx.listener)
|
||
}
|
||
}
|
||
|
||
/// The blasts the effects show and the clock they run on: the live ones, or (in a replay) the
|
||
/// recording's at the replay's moment, never the live world's.
|
||
fn presentation_context(&self) -> presentation::Context {
|
||
let world = self.world.clone();
|
||
if let Some(r) = self.presentation.playback() {
|
||
presentation::Context::playback(
|
||
if self.presentation.is_exporting() { presentation::Mode::Export } else { presentation::Mode::Replay },
|
||
self.presentation.generation(),
|
||
world,
|
||
self.sim.engine_tick,
|
||
self.sim.tick,
|
||
r.time(),
|
||
r.day_time(&self.sim),
|
||
r.rate(),
|
||
self.listener,
|
||
r.filming(),
|
||
)
|
||
} else {
|
||
presentation::Context::live(self.presentation.generation(), world, self.sim.engine_tick, self.sim.tick, self.sim.day_time, self.listener)
|
||
}
|
||
}
|
||
|
||
fn scene_snapshot(&self, ctx: &presentation::Context) -> scene::Snapshot<'_> {
|
||
if ctx.is_playback() && ctx.filming {
|
||
let source = self.presentation.playback()
|
||
.and_then(|r| self.sim.replay(r.rec))
|
||
.map(scene::Source::Recorded)
|
||
.unwrap_or(scene::Source::Empty);
|
||
scene::Snapshot::at_context(ctx, source)
|
||
} else {
|
||
scene::Snapshot::at_context(ctx, scene::Source::Live(&self.sim))
|
||
}
|
||
}
|
||
|
||
fn shown(&self, ctx: &presentation::Context) -> Shown {
|
||
let scene = self.scene_snapshot(ctx);
|
||
Shown::from_context(ctx, &scene)
|
||
}
|
||
|
||
/// The models to the game by handle: each name crosses once, the buffer stays allocated.
|
||
fn send_models(&mut self, models: &[sim::Model]) {
|
||
let generation = render::model_generation();
|
||
if generation != self.model_generation {
|
||
// The game's registry changed (or this is the first tick): ask again.
|
||
self.model_generation = generation;
|
||
self.model_ids.clear();
|
||
}
|
||
self.by_id.clear();
|
||
for m in models {
|
||
let ids = &mut self.model_ids;
|
||
let handle = *ids.entry(m.name).or_insert_with(|| render::model_id(m.name));
|
||
// A name the game's registry doesn't have draws nothing, by name too.
|
||
let Some(model) = handle else { continue };
|
||
let r = m.rotation.as_quat();
|
||
self.by_id.push(ModelInstanceId {
|
||
id: m.id,
|
||
model,
|
||
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,
|
||
});
|
||
}
|
||
if !render::set_models_by_id(generation, &self.by_id) {
|
||
// The registry changed between the two calls: ask again next tick.
|
||
self.model_generation = u32::MAX;
|
||
}
|
||
}
|
||
|
||
/// The engines the simulation or the replay declared become persistent sound sources (#95):
|
||
/// started, followed, stopped. The one-shots below stay as they were.
|
||
fn step_engines(&mut self, ctx: &presentation::Context, out: &mut Out) {
|
||
let replay = ctx.is_playback() && ctx.filming;
|
||
let cut = std::mem::take(&mut out.engine_cut) || replay != self.engines_replay;
|
||
self.engines_replay = replay;
|
||
let generation = render::sound_source_generation();
|
||
if generation != self.engine_gen {
|
||
// The game released every source (a world closed, a film began or ended).
|
||
self.engines.reset();
|
||
self.engine_gen = generation;
|
||
}
|
||
if self.engines.is_empty() && out.engines.is_empty() && out.engine_stops.is_empty() && !cut {
|
||
return;
|
||
}
|
||
let mut changes = self.engines.step(std::mem::take(&mut out.engines), cut, ctx.listener);
|
||
for key in std::mem::take(&mut out.engine_stops) {
|
||
if let Some(op) = self.engines.stop(key) { changes.push(op); }
|
||
}
|
||
let ops: Vec<render::SourceOp> = changes.into_iter()
|
||
.map(|op| match op {
|
||
engines::Op::Start(id, v) => source_op(render::SourceOpKind::Start, id, &v),
|
||
engines::Op::Update(id, v) => source_op(render::SourceOpKind::Update, id, &v),
|
||
engines::Op::Stop(id) => render::SourceOp {
|
||
kind: render::SourceOpKind::Stop,
|
||
id,
|
||
event: String::new(),
|
||
x: 0.0,
|
||
y: 0.0,
|
||
z: 0.0,
|
||
vx: 0.0,
|
||
vy: 0.0,
|
||
vz: 0.0,
|
||
gain: 0.0,
|
||
pitch: 1.0,
|
||
looping: false,
|
||
priority: 1.0,
|
||
attack: 0.0,
|
||
release: 0.0,
|
||
doppler: 0.0,
|
||
loop_from: 0.0,
|
||
loop_to: 0.0,
|
||
},
|
||
})
|
||
.collect();
|
||
if !ops.is_empty() && !render::sound_sources(generation, &ops) {
|
||
// Released between the two calls: start them again under the new generation.
|
||
self.engines.reset();
|
||
self.engine_gen = u32::MAX;
|
||
}
|
||
}
|
||
|
||
fn emit(&mut self, mut out: Out) {
|
||
let ctx = self.presentation_context();
|
||
self.step_engines(&ctx, &mut out);
|
||
if self.sim.shader {
|
||
render::set_params(&self.shader_params(&out, &ctx));
|
||
}
|
||
if self.hd {
|
||
// The camera's reaction to a near blast: a brief exposure and bloom punch.
|
||
let shown = self.shown(&ctx);
|
||
let p = self.viewer(&ctx).map_or(0.0, |e| {
|
||
shown.blasts.iter().map(|b| cinema::punch(b.size, shown.now - b.start as f32, b.at.distance(e))).fold(0.0, f32::max)
|
||
});
|
||
if (p - self.punch).abs() > 0.01 || (p == 0.0 && self.punch != 0.0) {
|
||
self.punch = p;
|
||
render::set_lighting(Lighting { hd: true, exposure: 1.0 + 0.4 * p, bloom: 0.55 + 0.9 * p });
|
||
}
|
||
render::set_lights(&self.lights(&out, &ctx));
|
||
self.sim.spot_hd = render::set_spot_lights(&self.spots(&ctx));
|
||
let (clock, segments) = self.shown_smoke(&ctx);
|
||
render::set_smoke(clock, &segments);
|
||
self.smoke.hd = horizon_mod_sdk::smoke_can_replace_fallback(&render::smoke_status());
|
||
} else {
|
||
self.smoke.hd = false;
|
||
}
|
||
if !out.models.is_empty() || self.sim.tick % 20 == 0 {
|
||
self.send_models(&out.models);
|
||
}
|
||
if !out.particles.is_empty() {
|
||
let hd_smoke = self.smoke.hd && !(ctx.is_playback() && ctx.filming);
|
||
let spawns: Vec<ParticleSpawn> = out
|
||
.particles
|
||
.into_iter()
|
||
// The long smoke is the renderer's volume then.
|
||
.filter(|p| !(hd_smoke && matches!(p.kind, "minecraft:campfire_cosy_smoke" | "minecraft:campfire_signal_smoke" | "minecraft:large_smoke")))
|
||
.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 sound_clock = ctx.sound_clock();
|
||
// Blasts play layered (cinema.rs), the nearest ones in full.
|
||
let mut booms: Vec<(f64, usize, DVec3, f32, f32)> = Vec::new();
|
||
// The game muffles by walls and distance itself (#96): the near variants play out to the
|
||
// reach of its tracing, so nothing is muffled twice; past it the far ones still do.
|
||
let far = if capabilities::ready(&capabilities::acoustics()) { ACOUSTIC_FAR } else { FAR };
|
||
for (event, at, volume, pitch) in out.sounds {
|
||
let dist = at.distance(ctx.listener);
|
||
if let Some(power) = cinema::blast_power(event) {
|
||
booms.push((dist, power, at, volume, pitch));
|
||
} else 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(PendingSound { due: sound_clock.deadline_after(delay), generation: ctx.generation, created_at: sound_clock, name, at, volume, pitch });
|
||
}
|
||
} else {
|
||
render::play_sound(event, at.x, at.y, at.z, volume, pitch);
|
||
}
|
||
}
|
||
booms.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||
for (rank, (dist, power, at, volume, pitch)) in booms.into_iter().enumerate() {
|
||
for l in cinema::layers(power, dist, far, volume, pitch, rank) {
|
||
// Seen first, heard later: each voice after the sound has travelled.
|
||
let delay = (dist / SOUND_SPEED) as u64 + l.delay;
|
||
if delay == 0 {
|
||
render::play_sound(&l.name, at.x, at.y, at.z, l.volume, l.pitch);
|
||
} else if self.pending.len() < 256 {
|
||
self.pending.push(PendingSound { due: sound_clock.deadline_after(delay), generation: ctx.generation, created_at: sound_clock, name: l.name, at, volume: l.volume, pitch: l.pitch });
|
||
}
|
||
}
|
||
}
|
||
let mut i = 0;
|
||
while i < self.pending.len() {
|
||
if self.pending[i].invalidated_by(ctx.generation, sound_clock) {
|
||
self.pending.swap_remove(i);
|
||
} else if sound_clock.has_reached(self.pending[i].due) {
|
||
let s = self.pending.swap_remove(i);
|
||
render::play_sound(&s.name, s.at.x, s.at.y, s.at.z, s.volume, s.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 pic = self.sim.air_picture();
|
||
// The command post's grid and replays cover the screen: the other panels wait under them.
|
||
if self.grid || self.presentation.playback().is_some() || (pic.tracks.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, &pic, player));
|
||
render::set_corner(render::Corner::BottomRight, radar::SIZE, radar::SIZE + 12.0, &radar::draw(&self.sim, player, yaw));
|
||
}
|
||
|
||
// ------------------------------------------------ saving
|
||
|
||
/// The state as text, lines of words: the autosave's format, and the body of a scenario.
|
||
/// `fresh`: every system and object whole, magazines full (a scenario to replay from the start).
|
||
fn state_text(&self, fresh: bool, view: bool) -> String {
|
||
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.filter(|_| !fresh).map_or("- - -".to_string(), |d| format!("{} {} {}", d.x, d.y, d.z));
|
||
let new = Sam::new(0, s.kind, s.pos, s.heading);
|
||
let (health, cargo, missiles, bursts, empty, reloading) = if fresh {
|
||
(new.health, new.cargo, new.missiles.saturating_sub(s.ground_rounds), new.bursts, false, 0)
|
||
} else {
|
||
(s.health, s.cargo, s.missiles, s.bursts, s.empty, s.reloading)
|
||
};
|
||
// The parts' states (sensor, mount, launcher, gun, tracks, comms) close the line; older saves lack them.
|
||
let comps = if fresh { new.comps } else { s.comps };
|
||
let parts = comps.0.iter().map(|v| format!("{v:.3}")).collect::<Vec<_>>().join(" ");
|
||
text += &format!(
|
||
"sam {} {} {} {} {} {} {} {} {} {} {} {} {dest} {parts} {} {} {} {} {} {} {} {} {} {}\n",
|
||
s.kind.key(),
|
||
s.pos.x,
|
||
s.pos.y,
|
||
s.pos.z,
|
||
s.heading,
|
||
s.roles,
|
||
health,
|
||
cargo,
|
||
missiles,
|
||
bursts,
|
||
u8::from(empty),
|
||
reloading,
|
||
s.ground_rounds, s.ground_stock, s.air_48n6_stock, s.mode.key(), s.radar_role.key(), if fresh { 0 } else { s.spent_cells }, u8::from(!fresh && s.ground_request), s.radar_on, !fresh && s.ground_return, !fresh && s.return_cargo,
|
||
);
|
||
}
|
||
for (i, t) in self.sim.targets.iter().enumerate() {
|
||
let h = if fresh { 100.0 } else { 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!("lastchance {}\n", self.sim.last_chance);
|
||
// A scenario to replay from the start begins with the full stock.
|
||
let (stock, progress) = if fresh { (sim::strike::TUNE.stock, 0) } else { (self.sim.strikes.stock, self.sim.strikes.progress) };
|
||
text += &format!("strikes {stock} {progress}\n");
|
||
if view {
|
||
text += &format!("far {}\n", self.far);
|
||
text += &format!("acoustics {}\n", self.acoustics_on());
|
||
text += &format!("effects {} {}\n", self.sim.shader, self.hd);
|
||
}
|
||
for (kind, roles) in &self.sim.roles {
|
||
text += &format!("roles {} {}\n", kind.key(), roles);
|
||
}
|
||
// Doctrines by the system's place in this file; the default ones aren't written.
|
||
for (i, s) in self.sim.sams.iter().enumerate().filter(|(_, s)| !s.doctrine.is_default()) {
|
||
text += &format!("doctrine {i} {}\n", s.doctrine.save_text());
|
||
}
|
||
text
|
||
}
|
||
|
||
fn save(&mut self) {
|
||
let text = self.state_text(false, true);
|
||
// Clean only once written: a failed write is tried again after a pause.
|
||
match storage::set(&self.state_key(), text.as_bytes()) {
|
||
Ok(()) => {
|
||
self.dirty = false;
|
||
self.next_save = self.sim.tick + 20;
|
||
}
|
||
Err(e) => {
|
||
horizon_mod_sdk::warn(&format!("could not save: {e}"));
|
||
self.next_save = self.sim.tick + 200;
|
||
}
|
||
}
|
||
}
|
||
|
||
fn load(&mut self) {
|
||
let key = self.state_key();
|
||
// A save from before worlds were told apart by seed (kept under the folder name alone) goes to the
|
||
// world that opens first under that name and is then removed, so a later world of the same name
|
||
// starts empty.
|
||
if storage::get(&key).is_none()
|
||
&& let Some(Some(id)) = &self.world
|
||
&& let Some((base, _)) = id.split_once('#')
|
||
{
|
||
let old = state_key_of(Some(base));
|
||
if storage::get(&old).is_some() {
|
||
self.load_from(&old);
|
||
let _ = storage::delete(&old);
|
||
self.dirty = true;
|
||
return;
|
||
}
|
||
}
|
||
self.load_from(&key);
|
||
}
|
||
|
||
fn load_from(&mut self, key: &str) {
|
||
let Some(bytes) = storage::get(key) else { return };
|
||
if let Err(e) = self.apply_state(&String::from_utf8_lossy(&bytes)) {
|
||
horizon_mod_sdk::warn(&format!("saved state not loaded: {e}"));
|
||
// The next autosave would write over it: keep the refused file for a look or a repair.
|
||
if let Err(e) = storage::set(&format!("{key}-refused"), &bytes) {
|
||
horizon_mod_sdk::warn(&format!("could not keep the refused state: {e}"));
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Adds the state in `text` (`state_text`'s lines; unknown lines are skipped, so older and
|
||
/// newer files read alike). The whole text is read and checked first: a bad line refuses all of it,
|
||
/// naming the line and field, and the scene stays as it was (#86).
|
||
fn apply_state(&mut self, text: &str) -> Result<(), String> {
|
||
let layout = layout::Layout::parse(text)?;
|
||
self.commit_layout(layout);
|
||
Ok(())
|
||
}
|
||
|
||
/// Adds a checked layout to the scene: nothing here can fail.
|
||
fn commit_layout(&mut self, layout: layout::Layout) {
|
||
let base = self.sim.sams.len();
|
||
for r in layout.sams {
|
||
let id = self.sim.id();
|
||
let mut sam = Sam::new(id, r.kind, r.pos, r.heading);
|
||
if let Some(v) = r.roles {
|
||
sam.roles = v;
|
||
}
|
||
if let Some(h) = r.health {
|
||
sam.health = h;
|
||
}
|
||
if let Some(c) = r.cargo {
|
||
sam.cargo = c;
|
||
}
|
||
// Older saves have no ammunition: full, as before.
|
||
if let Some((m, b, empty, reloading)) = r.ammo {
|
||
sam.missiles = m.min(sam.missiles);
|
||
sam.bursts = b.min(sam.bursts);
|
||
sam.empty = empty;
|
||
sam.reloading = reloading;
|
||
}
|
||
// The parts: absent in older saves, which load with every part whole.
|
||
for (v, c) in sam.comps.0.iter_mut().zip(&r.comps) {
|
||
*v = *c;
|
||
}
|
||
sam.ground_rounds = r.ground_rounds;
|
||
sam.ground_request = r.ground_request;
|
||
sam.ground_return = r.ground_return;
|
||
sam.return_cargo = r.return_cargo;
|
||
sam.ground_stock = r.ground_stock;
|
||
sam.air_48n6_stock = r.air_48n6_stock;
|
||
sam.fit_cells();
|
||
sam.set_mode(r.mode);
|
||
sam.set_radar_role(r.radar_role);
|
||
sam.radar_on = r.radar_on;
|
||
sam.spent_cells = r.spent_cells;
|
||
sam.sync_tube_cells();
|
||
self.sim.sams.push(sam);
|
||
if let Some(to) = r.dest {
|
||
let i = self.sim.sams.len() - 1;
|
||
self.sim.order_move(i, to);
|
||
}
|
||
}
|
||
for (pos, hp) in layout.targets {
|
||
self.sim.targets.push(pos);
|
||
self.sim.target_health.push(hp);
|
||
}
|
||
if let Some(d) = layout.damage {
|
||
self.sim.damage = d;
|
||
}
|
||
if let Some(l) = layout.last_chance {
|
||
self.sim.last_chance = l;
|
||
}
|
||
if let Some((stock, progress)) = layout.strikes {
|
||
self.sim.strikes.restore(stock, progress);
|
||
}
|
||
// A scenario's: the random generator, and the wave menu's raid.
|
||
if let Some(v) = layout.seed {
|
||
self.sim.reseed(v);
|
||
}
|
||
if let Some(w) = layout.wave {
|
||
let w: Vec<&str> = w.iter().map(String::as_str).collect();
|
||
self.wave.parse(&w);
|
||
}
|
||
if let Some(a) = layout.acoustics {
|
||
self.acoustics = Some(a);
|
||
render::set_acoustics(a);
|
||
}
|
||
if let Some(f) = layout.far {
|
||
self.far = f;
|
||
}
|
||
if let Some((shader, hd)) = layout.effects {
|
||
self.set_effects(shader, hd);
|
||
}
|
||
for (kind, r) in layout.roles {
|
||
self.sim.roles.insert(kind, r);
|
||
}
|
||
for (i, d) in layout.doctrines {
|
||
if let Some(s) = self.sim.sams.get_mut(base + i) {
|
||
s.doctrine = d;
|
||
}
|
||
}
|
||
}
|
||
|
||
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()));
|
||
}
|
||
}
|
||
|
||
/// The storage key of a world's state: a hash of its identity (`world_identity`).
|
||
fn state_key_of(world: Option<&str>) -> String {
|
||
match world {
|
||
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(),
|
||
}
|
||
}
|
||
|
||
/// Which world is open: its folder (`game.world-id`) and, for a saved world, its seed, so a new world
|
||
/// with the name of an old one has a layout of its own.
|
||
fn world_identity() -> Option<String> {
|
||
let id = game::world_id()?;
|
||
Some(match game::world_seed() {
|
||
Some(seed) => format!("{id}#{seed:x}"),
|
||
None => id,
|
||
})
|
||
}
|
||
|
||
/// What an autosave must not miss (#7, #113): the systems' places, ammunition and damage, the objects' health, and
|
||
/// the strike missiles' stock and refill. A change here marks the durable state dirty; the write itself is still
|
||
/// paced by `next_save`, and a failed write is retried.
|
||
fn durable_mark(sim: &Sim) -> u64 {
|
||
let st = &sim.strikes;
|
||
// The stock exactly; the refill at checkpoints, so that a tick-by-tick progress doesn't ask for a save (and a
|
||
// full state dump) every tick. A restart is at most `progress_save` ticks (5 s) behind on the next missile.
|
||
let strikes = u64::from(st.stock) | u64::from(st.progress / sim::strike::TUNE.progress_save.max(1)) << 8;
|
||
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;
|
||
let typed = u64::from(s.ground_rounds) ^ u64::from(s.ground_stock).rotate_left(17) ^ u64::from(s.air_48n6_stock).rotate_left(39) ^ u64::from(s.ground_request).rotate_left(55) ^ u64::from(s.ground_return).rotate_left(56) ^ u64::from(s.return_cargo).rotate_left(57);
|
||
let parts = s.comps.0.iter().fold(0u64, |a, v| a.wrapping_mul(131).wrapping_add((v * 100.0) as u64));
|
||
((s.health * 1000.0) as u64).wrapping_mul(1_000_003) ^ place ^ ammo.rotate_left(7) ^ parts.rotate_left(13) ^ typed.rotate_left(29) ^ (s.mode as u64).rotate_left(3) ^ (s.radar_role as u64).rotate_left(11) ^ u64::from(s.spent_cells).rotate_left(19) ^ u64::from(s.radar_on).rotate_left(23)
|
||
})
|
||
.chain(sim.target_health.iter().map(|h| (h * 10.0) as u64))
|
||
.fold(sim.sams.len() as u64, |a, h| a.wrapping_mul(31).wrapping_add(h))
|
||
.wrapping_mul(31)
|
||
.wrapping_add(strikes)
|
||
}
|
||
|
||
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 {
|
||
state_key_of(self.world.as_ref().and_then(|w| w.as_deref()))
|
||
}
|
||
|
||
/// 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();
|
||
}
|
||
self.end_session(presentation::ExitCause::WorldChange);
|
||
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.next_save = 0;
|
||
self.sim.shader = shader;
|
||
self.ground = Ground::default();
|
||
self.monitor = None;
|
||
self.map_close();
|
||
self.grid = false;
|
||
self.grid_ids.clear();
|
||
// The last world's transient state: its sounds were due on its own
|
||
// clock, its picked unit may have another meaning in this one, and
|
||
// its models would stay until the next full model list.
|
||
self.pending.clear();
|
||
self.moving = None;
|
||
render::set_models(&[]);
|
||
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);
|
||
}
|
||
|
||
/// The world's blocks as they were at the replay's moment `t` of raid `rec` (the holes the raid
|
||
/// made are not there yet); `show: false` puts the world back.
|
||
fn show_world_at(&mut self, rec: u32, t: f64, show: bool) {
|
||
let view = (|| {
|
||
let id = self.block_log.filter(|_| show)?;
|
||
let tick = self.sim.replay(rec)?.world_tick(t)?;
|
||
Some((id, tick))
|
||
})();
|
||
if view.is_some() || self.time_view {
|
||
render::set_world_time_view(view);
|
||
self.time_view = view.is_some();
|
||
}
|
||
}
|
||
|
||
/// Tells in the chat how far back the block log lets a replay of raid `rec` show the world.
|
||
fn say_block_log(&self, rec: &sim::record::Recording) {
|
||
let range = self.block_log.and_then(render::world_log_range);
|
||
let first = rec.first_tick();
|
||
match (range, first) {
|
||
(None, _) => say("Журнал блоков недоступен: в повторе мир такой, как сейчас (воронки уже на месте)"),
|
||
(Some((earliest, _)), Some(first)) if earliest > first => say(&format!(
|
||
"Журнал блоков начался позже налёта (на {} с): воронки до того уже в мире, он показан с самого раннего известного момента",
|
||
(earliest - first) / 20
|
||
)),
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
/// 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> {
|
||
switch_allowed(self.presentation.is_exporting())?;
|
||
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.say_block_log(rec);
|
||
let player = replay::Player::new(rec.number, mode, &self.sim);
|
||
// A film (its quality and effects) or another replay ends properly before this one.
|
||
self.end_session(presentation::ExitCause::Replaced);
|
||
self.presentation.replay(player);
|
||
self.grid = false;
|
||
input::claim_wheel(true);
|
||
Ok(())
|
||
}
|
||
|
||
fn stop_replay(&mut self) {
|
||
let was_export = self.presentation.is_exporting();
|
||
self.end_session(presentation::ExitCause::UserStop);
|
||
if was_export {
|
||
say("Экспорт отменён");
|
||
}
|
||
}
|
||
|
||
/// Ends whatever replay or film shows, on every path: the film quality, the effects, the
|
||
/// clean HUD, the views and the time and camera overrides go back to the live game's.
|
||
fn end_session(&mut self, cause: presentation::ExitCause) {
|
||
let cleanup = if cause == presentation::ExitCause::WorldChange {
|
||
self.presentation.world_changed()
|
||
} else {
|
||
self.presentation.end(cause)
|
||
};
|
||
let Some(cleanup) = cleanup else { return };
|
||
cleanup.apply(self);
|
||
}
|
||
|
||
/// Plays the director's film of the last raid at the best quality: HD effects on (restored after).
|
||
fn start_film(&mut self, which: &str, export: Option<&ExportOpts>) -> Result<(), String> {
|
||
if export.is_none() {
|
||
switch_allowed(self.presentation.is_exporting())?;
|
||
}
|
||
let n = self.sim.replays.len();
|
||
if n == 0 {
|
||
return Err("Повторов пока нет: запишется первый же налёт (когда небо очистится)".into());
|
||
}
|
||
let which = match which {
|
||
"best" => film::Which::Best,
|
||
"all" => film::Which::All,
|
||
n => film::Which::Top(n.parse().map_err(|_| "/airdef replay film [best|all|N]")?),
|
||
};
|
||
let rec = &self.sim.replays[n - 1];
|
||
let f = film::Film::build(rec, which).ok_or("В этом налёте нечего показать")?;
|
||
self.say_block_log(rec);
|
||
let mut player = replay::Player::new(rec.number, replay::Mode::Film(Box::new(f)), &self.sim);
|
||
if let Some(o) = export {
|
||
player.wait = true;
|
||
player.clean = true;
|
||
player.limit = o.seconds;
|
||
}
|
||
// What was shown ends first (its effects are remembered below, not lost).
|
||
self.end_session(presentation::ExitCause::Replaced);
|
||
self.presentation.replay(player);
|
||
self.grid = false;
|
||
input::claim_wheel(true);
|
||
// The best picture: HD on, the renderer's film quality (full-size world, more cloud and fog steps).
|
||
if self.film_prev.is_none() {
|
||
self.film_prev = Some((self.sim.shader, self.hd));
|
||
}
|
||
self.set_effects(true, true);
|
||
render::set_film_quality(true);
|
||
Ok(())
|
||
}
|
||
|
||
/// `/airdef replay export [имя] [best|all|N] [fps=60] [size=1920x1080] [crf=14] [sec=N] [noaudio]`.
|
||
fn start_export(&mut self, args: &[&str]) -> Result<(), String> {
|
||
let mut o = ExportOpts { name: String::new(), which: "best".into(), fps: 60, size: (1920, 1080), crf: 14, audio: true, seconds: None };
|
||
for a in args {
|
||
if let Some(v) = a.strip_prefix("fps=") {
|
||
o.fps = v.parse().map_err(|_| "fps=число")?;
|
||
} else if let Some(v) = a.strip_prefix("size=") {
|
||
let (w, h) = v.split_once('x').ok_or("size=1920x1080")?;
|
||
o.size = (w.parse().map_err(|_| "size=1920x1080")?, h.parse().map_err(|_| "size=1920x1080")?);
|
||
} else if let Some(v) = a.strip_prefix("crf=") {
|
||
o.crf = v.parse().map_err(|_| "crf=число")?;
|
||
} else if let Some(v) = a.strip_prefix("sec=") {
|
||
o.seconds = Some(v.parse().map_err(|_| "sec=число")?);
|
||
} else if *a == "noaudio" {
|
||
o.audio = false;
|
||
} else if matches!(*a, "best" | "all") || a.parse::<usize>().is_ok() {
|
||
o.which = a.to_string();
|
||
} else {
|
||
o.name = a.chars().filter(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_')).collect();
|
||
}
|
||
}
|
||
if self.presentation.is_exporting() {
|
||
return Err("Экспорт уже идёт (/airdef replay stop — отмена)".into());
|
||
}
|
||
if o.name.is_empty() {
|
||
let n = self.sim.replays.last().map_or(0, |r| r.number);
|
||
o.name = format!("raid{n}-{}", o.which);
|
||
}
|
||
let which = o.which.clone();
|
||
self.start_film(&which, Some(&o))?;
|
||
let state = self.presentation.take();
|
||
let playback = match state {
|
||
presentation::State::Replay(player) => player,
|
||
other => {
|
||
self.presentation.restore(other);
|
||
self.end_session(presentation::ExitCause::Failed);
|
||
return Err("Не удалось передать фильм в захват".into());
|
||
}
|
||
};
|
||
say(&format!("Экспорт «{}»: {} fps, {}x{}; планирую кадры…", o.name, o.fps, o.size.0, o.size.1));
|
||
self.presentation.export(playback, Export { generation: self.presentation.generation(), opts: o, stage: Stage::Planning, ticks: 0 });
|
||
Ok(())
|
||
}
|
||
|
||
/// Drives an export: plan, start the recorder, wait for its first frame, report, stop at the end.
|
||
fn export_step(&mut self, r: &mut replay::Player, ex: &mut Export) -> Option<Result<(), String>> {
|
||
if ex.generation != self.presentation.generation() {
|
||
// The film this export recorded was replaced: the recorder stops, nothing else drives it.
|
||
say("Экспорт отменён: показ заменён другим");
|
||
return Some(Err("показ заменён другим".into()));
|
||
}
|
||
ex.ticks += 1;
|
||
let st = render::capture_status();
|
||
let owner = render::capture_owner_status();
|
||
if ex.stage != Stage::Planning {
|
||
if let Some(problem) = capabilities::capture_problem(&owner) {
|
||
let message = if st.message.is_empty() { problem.to_string() } else { format!("{problem}: {}", st.message) };
|
||
say(&format!("Экспорт не удался: {message}"));
|
||
r.done = true;
|
||
return Some(Err(message));
|
||
}
|
||
if ex.stage == Stage::Arming && ex.ticks > 600 {
|
||
let message = "Движок не подтвердил подготовку захвата за 600 тиков".to_string();
|
||
say(&message);
|
||
r.done = true;
|
||
return Some(Err(message));
|
||
}
|
||
}
|
||
let failed = |s: &render::CaptureState| s.phase == render::CapturePhase::Failed;
|
||
let mut finish: Option<Result<String, String>> = None;
|
||
match ex.stage {
|
||
Stage::Planning if r.film_ready() => {
|
||
let o = &ex.opts;
|
||
let res = render::capture_start(&render::CaptureOptions {
|
||
folder: "airdef-films".into(),
|
||
name: o.name.clone(),
|
||
fps: o.fps,
|
||
width: o.size.0,
|
||
height: o.size.1,
|
||
crf: o.crf,
|
||
audio: o.audio,
|
||
warmup: 8,
|
||
});
|
||
match res {
|
||
Ok(()) => {
|
||
say(&format!("Кадры готовы ({}); запись…", r.film_summary()));
|
||
ex.stage = Stage::Arming;
|
||
ex.ticks = 0;
|
||
}
|
||
Err(e) => finish = Some(Err(e)),
|
||
}
|
||
}
|
||
Stage::Arming => {
|
||
if st.phase == render::CapturePhase::Recording && capabilities::ready(&owner) {
|
||
r.wait = false;
|
||
ex.stage = Stage::Recording;
|
||
ex.ticks = 0;
|
||
} else if failed(&st) {
|
||
finish = Some(Err(st.message.clone()));
|
||
}
|
||
}
|
||
Stage::Recording => {
|
||
if failed(&st) {
|
||
finish = Some(Err(st.message.clone()));
|
||
} else if r.ended {
|
||
render::capture_stop(false);
|
||
ex.stage = Stage::Finishing;
|
||
} else if ex.ticks % 100 == 0 {
|
||
let len = r.film_len().unwrap_or(1.0).max(0.1);
|
||
say(&format!("Экспорт: {:.0}% ({} кадров)", (r.film_time() / len * 100.0).min(100.0), st.frames));
|
||
}
|
||
}
|
||
Stage::Finishing => match st.phase {
|
||
render::CapturePhase::Done if capabilities::ready(&owner) => {
|
||
let note = if st.message.is_empty() { String::new() } else { format!(" ({})", st.message) };
|
||
finish = Some(Ok(format!("{}x{}, {} кадров: {}{note}", st.width, st.height, st.frames, st.file)));
|
||
}
|
||
render::CapturePhase::Failed => finish = Some(Err(st.message.clone())),
|
||
_ => {}
|
||
},
|
||
_ => {}
|
||
}
|
||
if let Some(res) = finish {
|
||
match &res {
|
||
Ok(m) => say(&format!("Экспорт готов: {m}")),
|
||
Err(e) => say(&format!("Экспорт не удался: {e}")),
|
||
}
|
||
r.done = true;
|
||
return Some(res.map(|_| ()));
|
||
}
|
||
None
|
||
}
|
||
|
||
/// 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 deploy_configured(&mut self, key: &str) -> Result<String, String> {
|
||
let (kind, mode, role) = deploy_configuration(key).ok_or("Неизвестный вид техники")?;
|
||
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 id = self.sim.id();
|
||
let mut sam = Sam::new(id, kind, at, (-flat.x).atan2(-flat.z));
|
||
sam.set_mode(mode);
|
||
sam.set_radar_role(role);
|
||
if let Some(r) = self.sim.roles.get(&kind) { sam.roles = *r; }
|
||
self.sim.sams.push(sam);
|
||
self.sim.settle(id);
|
||
self.dirty = true;
|
||
Ok(format!("{} развёрнут ({}, {})", kind.name(), mode.key(), role.key()))
|
||
}
|
||
|
||
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_BATTERY, label: "Разместить элементы батареи…".into() }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_GRID, label: "Командный пункт: все комплексы (J)".into() }));
|
||
let custom = self.sim.sams.iter().filter(|s| !s.doctrine.is_default()).count();
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_DOCTRINE, label: format!("Доктрины: охрана, сектор, резерв (особых: {custom})…") }));
|
||
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::BatteryDeploy => {
|
||
title = "Размещение батареи — клик создаёт технику перед игроком".into();
|
||
widgets.push(Widget::List(ListWidget { id: BATTERY_ROWS, rows: BATTERY_DEPLOY.iter().map(|(_, name)| (*name).to_string()).collect(), selected: None }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, 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_ACOUSTICS, label: format!("Акустика (преграды, эхо): {}", onoff(self.acoustics_on())) }));
|
||
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::Fleet => {
|
||
title = "Доктрины — клик по комплексу".to_string();
|
||
let rows = self
|
||
.fleet()
|
||
.iter()
|
||
.map(|&i| {
|
||
let s = &self.sim.sams[i];
|
||
format!("№{} {} · {}", i + 1, s.kind.name(), s.doctrine.text(&self.sim.targets))
|
||
})
|
||
.collect();
|
||
widgets.push(Widget::List(ListWidget { id: FLEET_ROWS, rows, selected: None }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_BACK, label: "← Назад".into() }));
|
||
}
|
||
Page::Doctrine(id) => {
|
||
let Some(i) = self.sim.sams.iter().position(|s| s.id == id) else { return self.open_menu(Page::Fleet) };
|
||
let s = &self.sim.sams[i];
|
||
let d = &s.doctrine;
|
||
title = format!("№{} {} — доктрина (объяснение: /airdef why {})", i + 1, s.kind.name(), i + 1);
|
||
let guard = match d.guards.len() {
|
||
0 => "нет (все цели своих классов)".to_string(),
|
||
1 => sim::doctrine::object_name(&self.sim.targets, d.guards[0]),
|
||
n => format!("{n} объектов (клик — снять)"),
|
||
};
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_GUARD, label: format!("Охраняемый объект: {guard}") }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_SECTOR_DIR, label: format!("Сектор: {}", d.sector_text()) }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_SECTOR_WIDTH, label: format!("Ширина сектора: ±{:.0}°", d.sector.map_or(45.0, |(_, h)| h.to_degrees())) }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_RESERVE, label: format!("Резерв ракет: {} (в магазине {})", d.reserve, s.missiles) }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_SALVO, label: format!("Залп по цели: {}", d.salvo.name()) }));
|
||
widgets.push(Widget::Button(ButtonWidget { id: BTN_DOC_RESET, label: "Сбросить доктрину".into() }));
|
||
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 });
|
||
}
|
||
|
||
/// The systems that have a doctrine to set: those with missiles (indices into the sim's list).
|
||
fn fleet(&self) -> Vec<usize> {
|
||
(0..self.sim.sams.len()).filter(|&i| self.sim.sams[i].kind.armed()).collect()
|
||
}
|
||
|
||
/// Changes one system's doctrine (the menu's buttons and `/airdef doctrine`).
|
||
fn edit_doctrine(&mut self, i: usize, f: impl FnOnce(&mut sim::doctrine::Doctrine)) {
|
||
if let Some(s) = self.sim.sams.get_mut(i) {
|
||
f(&mut s.doctrine);
|
||
// It chooses again under the new rules.
|
||
s.target = None;
|
||
s.gun_target = None;
|
||
self.dirty = true;
|
||
}
|
||
}
|
||
|
||
/// `/airdef doctrine [<n|all> reserve K | salvo eco|normal|heavy | sector C H | sector off | guard N[,M]|off | reset]` (#47).
|
||
fn doctrine_command(&mut self, w: &[&str]) -> Result<String, String> {
|
||
const USAGE: &str = "/airdef doctrine <номер|all> reserve <K> | salvo eco|normal|heavy | sector <центр°> <полуширина°> | sector off | guard <объект№>[,<№>] | guard off | reset";
|
||
let Some((who, what)) = w.split_first() else {
|
||
for i in self.fleet() {
|
||
let s = &self.sim.sams[i];
|
||
say(&format!("№{} {}: {}", i + 1, s.kind.name(), s.doctrine.text(&self.sim.targets)));
|
||
}
|
||
return Ok(format!("Изменить: {USAGE}"));
|
||
};
|
||
let which: Vec<usize> = if *who == "all" {
|
||
self.fleet()
|
||
} else {
|
||
let i = who.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).filter(|&i| self.sim.sams.get(i).is_some_and(|s| s.kind.armed())).ok_or("Нет такого вооружённого комплекса")?;
|
||
vec![i]
|
||
};
|
||
let num = |v: Option<&&str>, what: &str, lo: f64, hi: f64| -> Result<f64, String> {
|
||
v.and_then(|v| v.parse::<f64>().ok()).filter(|x| x.is_finite() && (lo..=hi).contains(x)).ok_or(format!("{what}: число от {lo} до {hi}"))
|
||
};
|
||
let mut edit: Box<dyn Fn(&mut sim::doctrine::Doctrine)> = match what {
|
||
["reserve", k] => {
|
||
let k = num(Some(k), "резерв", 0.0, sim::doctrine::MAX_RESERVE as f64)? as u32;
|
||
Box::new(move |d| d.reserve = k)
|
||
}
|
||
["salvo", v] => {
|
||
let v = sim::doctrine::Salvo::from_key(v).ok_or("Залп: eco, normal или heavy")?;
|
||
Box::new(move |d| d.salvo = v)
|
||
}
|
||
["sector", "off"] => Box::new(|d| d.sector = None),
|
||
["sector", c, h] => {
|
||
let c = num(Some(c), "центр сектора", -720.0, 720.0)?.to_radians();
|
||
let h = num(Some(h), "полуширина сектора", 0.0, 180.0)?.to_radians();
|
||
Box::new(move |d| d.sector = Some((c, h)))
|
||
}
|
||
["guard", "off"] => Box::new(|d| d.guards.clear()),
|
||
["guard", list] => {
|
||
let mut at = Vec::new();
|
||
for n in list.split(',') {
|
||
let k = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).and_then(|k| self.sim.targets.get(k)).ok_or(format!("Нет объекта «{n}» (отметьте его /airdef target here)"))?;
|
||
at.push(*k);
|
||
}
|
||
Box::new(move |d| d.guards = at.clone())
|
||
}
|
||
["reset"] => Box::new(|d| *d = sim::doctrine::Doctrine::default()),
|
||
_ => return Err(USAGE.into()),
|
||
};
|
||
for &i in &which {
|
||
self.edit_doctrine(i, &mut edit);
|
||
}
|
||
let first = which.first().map(|&i| self.sim.sams[i].doctrine.text(&self.sim.targets)).unwrap_or_default();
|
||
Ok(format!("Доктрина ({} компл.): {first}", which.len()))
|
||
}
|
||
|
||
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;
|
||
}
|
||
}
|
||
|
||
impl presentation::CleanupHost for AirDef {
|
||
fn apply_cleanup_action(&mut self, action: presentation::CleanupAction) {
|
||
match action {
|
||
presentation::CleanupAction::CancelCapture => render::capture_stop(true),
|
||
presentation::CleanupAction::ClearPendingSounds => self.pending.clear(),
|
||
presentation::CleanupAction::RestoreFilmQuality => render::set_film_quality(false),
|
||
presentation::CleanupAction::RestoreEffects => {
|
||
if let Some((shader, hd)) = self.film_prev.take() {
|
||
self.set_effects(shader, hd);
|
||
}
|
||
}
|
||
presentation::CleanupAction::RestoreWorldView => self.show_world_at(0, 0.0, false),
|
||
presentation::CleanupAction::ClearTimeOverride => render::set_time_override(None),
|
||
presentation::CleanupAction::ClearMainView => render::set_main_view(None),
|
||
presentation::CleanupAction::ReleaseWheel => input::claim_wheel(false),
|
||
presentation::CleanupAction::ClearHud => render::set_hud(&[]),
|
||
presentation::CleanupAction::ClearViews => render::set_views(&[]),
|
||
presentation::CleanupAction::HideMonitor => self.monitor_shown = false,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The help line: generated from the command tree (`commands.rs`), which the game checks lines with.
|
||
fn help() -> String {
|
||
commands::help()
|
||
}
|
||
|
||
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,
|
||
next_save: 0,
|
||
hud_shown: false,
|
||
monitor: None,
|
||
monitor_shown: false,
|
||
grid: false,
|
||
grid_ids: Vec::new(),
|
||
wave: wave::WaveConfig::default(),
|
||
presentation: presentation::Session::default(),
|
||
block_log: None,
|
||
time_view: false,
|
||
film_prev: None,
|
||
smoke: Default::default(),
|
||
far: true,
|
||
acoustics: None,
|
||
moving: None,
|
||
hd: false,
|
||
world: None,
|
||
health_mark: 0,
|
||
menu: None,
|
||
listener: DVec3::ZERO,
|
||
punch: 0.0,
|
||
pending: Vec::new(),
|
||
engines: engines::Engines::default(),
|
||
engine_gen: u32::MAX,
|
||
engines_replay: false,
|
||
model_ids: std::collections::HashMap::new(),
|
||
model_generation: u32::MAX,
|
||
by_id: Vec::new(),
|
||
map: map::MapUi::default(),
|
||
};
|
||
let _ = input::register_key("map", "Карта: командная, расстановка", "key.keyboard.m");
|
||
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.block_log = Some(render::world_log_start());
|
||
me.sim.shader = true;
|
||
me.apply_far();
|
||
// Subcommands, typed arguments and the saved scenarios' names for the chat box (#98).
|
||
commands::register(&scenario::saved_names());
|
||
Ok((me, Registration::new().command("airdef").on_tick()))
|
||
}
|
||
|
||
fn tick(&mut self, tick: u64) {
|
||
self.sim.engine_tick = tick;
|
||
// Each world keeps its own systems, objects and settings: loaded when it opens.
|
||
let world = world_identity();
|
||
if self.world.as_ref() != Some(&world) {
|
||
self.open_world(world);
|
||
// `open_world` replaces Sim and resets its host clock; restore this callback's tick.
|
||
self.sim.engine_tick = tick;
|
||
}
|
||
let Some(p) = player() else { return };
|
||
for event in input::poll() {
|
||
match event {
|
||
Event::UseStart(u) => self.use_item(&u.item.id),
|
||
Event::KeyDown(k) if k == "map" => self.map_toggle(),
|
||
Event::KeyDown(k) if k == "menu" => {
|
||
if self.presentation.playback().is_some() {
|
||
self.stop_replay();
|
||
}
|
||
self.open_menu(Page::Main)
|
||
}
|
||
Event::KeyDown(k) if k == "rp_exit" && self.presentation.playback().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) = self.presentation.playback_mut()
|
||
&& let Some(rec) = self.sim.replay(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.presentation.playback().is_some() {
|
||
self.stop_replay();
|
||
} else if let Err(e) = self.start_replay("map", None) {
|
||
say(&e);
|
||
}
|
||
}
|
||
Event::Wheel(w) => {
|
||
if let Some(r) = self.presentation.playback_mut()
|
||
&& let Some(rec) = self.sim.replay(r.rec)
|
||
{
|
||
r.wheel(w, rec);
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
let now = self.sim.tick;
|
||
// The blocks themselves (issues #42, #43): what changed, and the sections asked for last tick. First, so
|
||
// that the answers below are judged by the world they come in.
|
||
let changes = render::world_changes();
|
||
self.ground.world.changed_rev(changes.epoch, changes.revision, changes.overflow, &changes.sections);
|
||
self.ground.answer(render::ground(), now);
|
||
let sections = render::sections()
|
||
.into_iter()
|
||
.map(|s| sim::world::SectionAnswer {
|
||
sec: (s.x, s.y, s.z),
|
||
fill: match s.fill {
|
||
render::SectionFill::Unknown => sim::world::Fill::Unknown,
|
||
render::SectionFill::Empty => sim::world::Fill::Empty,
|
||
render::SectionFill::Full => sim::world::Fill::Full,
|
||
render::SectionFill::Mixed => match <[u8; 512]>::try_from(s.bits) {
|
||
Ok(bits) => sim::world::Fill::Mixed(Box::new(bits)),
|
||
Err(_) => sim::world::Fill::Unknown,
|
||
},
|
||
},
|
||
})
|
||
.collect();
|
||
self.ground.world.answer(sections, now);
|
||
// Exact collision shapes of blocks a flight met (#63): the answers to last tick's rays.
|
||
let replies: Vec<sim::world::RayReply> = render::rays()
|
||
.into_iter()
|
||
.map(|r| sim::world::RayReply {
|
||
id: r.id,
|
||
clear: matches!(r.verdict, render::Verdict::Clear),
|
||
hit: matches!(r.verdict, render::Verdict::Hit),
|
||
fraction: r.fraction,
|
||
normal: [r.normal.0, r.normal.1, r.normal.2],
|
||
block: [r.block.0, r.block.1, r.block.2],
|
||
})
|
||
.collect();
|
||
self.ground.world.answer_rays(&replies);
|
||
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.day_time = game::get_clock().map(|c| c.day_time);
|
||
self.sim.step(&mut self.ground, Some(DVec3::new(p.x, p.y, p.z)), &mut out);
|
||
let context = presentation::Context::live(self.presentation.generation(), self.world.clone(), self.sim.engine_tick, self.sim.tick, self.sim.day_time, self.listener);
|
||
let scene = scene::Snapshot::at_context(&context, scene::Source::Live(&self.sim));
|
||
self.smoke.update(&scene);
|
||
let wanted = self.ground.take_wanted();
|
||
if !wanted.is_empty() {
|
||
render::query_ground(&wanted);
|
||
}
|
||
// The chunks the launch-site search is looking at: the game loads them for a few seconds (API 22).
|
||
let chunks = self.ground.take_chunks();
|
||
if !chunks.is_empty() {
|
||
render::load_chunks(&chunks);
|
||
}
|
||
let rays: Vec<render::Ray> = self
|
||
.ground
|
||
.world
|
||
.take_rays(now)
|
||
.into_iter()
|
||
.map(|(id, a, b)| render::Ray { id, start: (a.x, a.y, a.z), end: (b.x, b.y, b.z), policy: render::Policy::Collision })
|
||
.collect();
|
||
if !rays.is_empty() {
|
||
render::query_rays(&rays);
|
||
}
|
||
let sections = self.ground.world.take_wanted(now);
|
||
if !sections.is_empty() {
|
||
render::query_sections(render::Policy::Collision, §ions);
|
||
}
|
||
let tick_context = self.presentation_context();
|
||
match self.presentation.take() {
|
||
presentation::State::Live => {}
|
||
presentation::State::Replay(mut playback) => {
|
||
if playback.filming() {
|
||
out.models.clear();
|
||
out.particles.clear();
|
||
out.sounds.clear();
|
||
out.engines.clear();
|
||
out.engine_stops.clear();
|
||
out.shake = None;
|
||
}
|
||
playback.tick(&self.sim, &mut self.ground, tick_context.listener, &mut out);
|
||
if playback.done {
|
||
self.presentation.restore(presentation::State::Replay(playback));
|
||
self.end_session(presentation::ExitCause::Finished);
|
||
} else {
|
||
self.presentation.restore(presentation::State::Replay(playback));
|
||
}
|
||
}
|
||
presentation::State::Export { mut playback, mut export } => {
|
||
let progress = if export.generation != self.presentation.generation() {
|
||
Some(Err("показ заменён другим".into()))
|
||
} else {
|
||
if playback.filming() {
|
||
out.models.clear();
|
||
out.particles.clear();
|
||
out.sounds.clear();
|
||
out.engines.clear();
|
||
out.engine_stops.clear();
|
||
out.shake = None;
|
||
}
|
||
playback.tick(&self.sim, &mut self.ground, tick_context.listener, &mut out);
|
||
self.export_step(&mut playback, &mut export)
|
||
};
|
||
let cause = match progress {
|
||
Some(Ok(())) => Some(presentation::ExitCause::Finished),
|
||
Some(Err(_)) => Some(presentation::ExitCause::Failed),
|
||
None if playback.done => Some(presentation::ExitCause::Failed),
|
||
None => None,
|
||
};
|
||
self.presentation.restore(presentation::State::Export { playback, export });
|
||
if let Some(cause) = cause {
|
||
self.end_session(cause);
|
||
}
|
||
}
|
||
}
|
||
self.emit(out);
|
||
self.map.sample(&self.sim);
|
||
// The map's events and shapes: at the tick's pace (a frame hook's budget is too small for it).
|
||
self.map_frame();
|
||
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.
|
||
let ctx = self.presentation_context();
|
||
if let Some(r) = self.presentation.playback() {
|
||
let size = render::gui_size();
|
||
render::set_hud(&r.hud(&self.sim, size));
|
||
render::set_views(&r.views(size));
|
||
// The world through the director's camera, with the full pipeline (HD, the post pass).
|
||
render::set_main_view(r.filming().then(|| r.view_id()));
|
||
// The sky of the raid, not of now (None for a raid whose clock was unknown).
|
||
render::set_time_override(ctx.day_time);
|
||
self.show_world_at(r.rec, r.time(), r.filming());
|
||
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 = durable_mark(&self.sim);
|
||
if mark != self.health_mark {
|
||
self.health_mark = mark;
|
||
self.dirty = true;
|
||
}
|
||
if self.dirty && self.sim.tick >= self.next_save {
|
||
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::Main, BTN_BATTERY) => {
|
||
self.open_menu(Page::BatteryDeploy);
|
||
return;
|
||
}
|
||
(Page::BatteryDeploy, BATTERY_ROWS) => {
|
||
if let Some((key, _)) = BATTERY_DEPLOY.get(row as usize) {
|
||
match self.deploy_configured(key) {
|
||
Ok(message) => say(&message),
|
||
Err(error) => say(&error),
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
(Page::BatteryDeploy, BTN_BACK) => {
|
||
self.open_menu(Page::Main);
|
||
return;
|
||
}
|
||
(Page::Main, BTN_DOCTRINE) => {
|
||
self.open_menu(Page::Fleet);
|
||
return;
|
||
}
|
||
(Page::Fleet, FLEET_ROWS) => {
|
||
if let Some(&i) = self.fleet().get(row as usize) {
|
||
self.open_menu(Page::Doctrine(self.sim.sams[i].id));
|
||
}
|
||
return;
|
||
}
|
||
(Page::Fleet, BTN_BACK) => {
|
||
self.open_menu(Page::Main);
|
||
return;
|
||
}
|
||
(Page::Doctrine(_), BTN_BACK) => {
|
||
self.open_menu(Page::Fleet);
|
||
return;
|
||
}
|
||
(Page::Doctrine(id), b) => {
|
||
let Some(i) = self.sim.sams.iter().position(|s| s.id == id) else { return };
|
||
let objects = self.sim.targets.clone();
|
||
match b {
|
||
BTN_RESERVE => self.edit_doctrine(i, |d| d.reserve = [0, 1, 2, 4, 8, 16].into_iter().find(|&r| r > d.reserve).unwrap_or(0)),
|
||
BTN_SALVO => self.edit_doctrine(i, |d| d.salvo = d.salvo.next()),
|
||
// Eight directions of 45 degrees, then off.
|
||
BTN_SECTOR_DIR => self.edit_doctrine(i, |d| {
|
||
let half = d.sector.map_or(45f64.to_radians(), |(_, h)| h);
|
||
d.sector = match d.sector {
|
||
None => Some((0.0, half)),
|
||
Some((c, _)) if (c.to_degrees().rem_euclid(360.0) / 45.0).round() < 7.0 => Some((c + 45f64.to_radians(), half)),
|
||
Some(_) => None,
|
||
};
|
||
}),
|
||
BTN_SECTOR_WIDTH => self.edit_doctrine(i, |d| {
|
||
if let Some((c, h)) = d.sector {
|
||
let deg = [30.0, 45.0, 60.0, 90.0, 135.0].into_iter().find(|&w| w > h.to_degrees() + 0.5).unwrap_or(30.0);
|
||
d.sector = Some((c, f64::to_radians(deg)));
|
||
}
|
||
}),
|
||
// None, then each object in turn, then none.
|
||
BTN_GUARD => self.edit_doctrine(i, |d| {
|
||
let at = d.guards.first().and_then(|g| objects.iter().position(|t| t.distance(*g) < 16.0));
|
||
d.guards = match (d.guards.len(), at) {
|
||
(0, _) => objects.first().copied().into_iter().collect(),
|
||
(1, Some(k)) => objects.get(k + 1).copied().into_iter().collect(),
|
||
_ => Vec::new(),
|
||
};
|
||
}),
|
||
BTN_DOC_RESET => self.edit_doctrine(i, |d| *d = sim::doctrine::Doctrine::default()),
|
||
_ => 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_ACOUSTICS) => {
|
||
let on = !self.acoustics_on();
|
||
self.acoustics = Some(on);
|
||
render::set_acoustics(on);
|
||
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
|
||
}
|
||
["capabilities"] => Some(capabilities::diagnostics()),
|
||
["monitor"] => {
|
||
self.cycle_monitor();
|
||
None
|
||
}
|
||
["grid"] => {
|
||
self.grid = !self.grid;
|
||
None
|
||
}
|
||
["give"] => {
|
||
self.give();
|
||
None
|
||
}
|
||
["deploy", kind] => Some(self.deploy_configured(kind)?),
|
||
["battery"] => {
|
||
let status = self.sim.battery_status();
|
||
for entry in status { say(&battery_view::status(entry)); }
|
||
Some("/airdef battery <номер> integrated|launcher; /airdef radar <номер> on|off|multi|search|engagement|height".into())
|
||
}
|
||
["battery", n, mode] => {
|
||
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("Нужен номер комплекса")?;
|
||
let mode = sim::battery::SamMode::from_key(mode).ok_or("Режим: integrated или launcher")?;
|
||
let sam = self.sim.sams.get_mut(i).ok_or("Нет такого комплекса")?;
|
||
if !sam.set_mode(mode) { return Err("Отдельная пусковая доступна для С-400 и С-500".into()); }
|
||
self.dirty = true;
|
||
Some(format!("№{} {}: режим {}", i + 1, sam.kind.name(), mode.key()))
|
||
}
|
||
["radar", n, state @ ("on" | "off")] => {
|
||
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("Нужен номер комплекса")?;
|
||
let sam = self.sim.sams.get_mut(i).ok_or("Нет такого комплекса")?;
|
||
if sam.kind.spec().sensor <= 0.0 || sam.mode == sim::battery::SamMode::LauncherOnly { return Err("У комплекса нет активной РЛС".into()); }
|
||
sam.radar_on = *state == "on";
|
||
self.dirty = true;
|
||
Some(format!("№{} {}: излучение РЛС {}", i + 1, sam.kind.name(), state))
|
||
}
|
||
["radar", n, role] => {
|
||
let i = n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("Нужен номер РЛС")?;
|
||
let role = sim::battery::RadarRole::from_key(role).ok_or("Роль: multi, search, engagement или height")?;
|
||
let sam = self.sim.sams.get_mut(i).ok_or("Нет такого комплекса")?;
|
||
if !sam.set_radar_role(role) { return Err("Нужна отдельная РЛС".into()); }
|
||
self.dirty = true;
|
||
Some(format!("№{} РЛС: роль {}", i + 1, role.key()))
|
||
}
|
||
["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(wave::DIST_MIN, wave::DIST_MAX);
|
||
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",
|
||
)?;
|
||
// Through the menu's path (`order_raid`), so every drone leaves a launch site.
|
||
let order = sim::RaidOrder { kinds: vec![(kind, count)], approach: sim::Approach::Sector, dist, aim: sim::Aim::Objects };
|
||
self.sim.order_raid(&order, &[target], &mut out);
|
||
}
|
||
None
|
||
}
|
||
["replay", rest @ ..] => {
|
||
match rest.first().copied().unwrap_or("map") {
|
||
"stop" => self.stop_replay(),
|
||
"film" => self.start_film(rest.get(1).copied().unwrap_or("best"), None)?,
|
||
"export" => self.start_export(&rest[1..])?,
|
||
what => self.start_replay(what, None)?,
|
||
}
|
||
None
|
||
}
|
||
["scenario", rest @ ..] => Some(self.scenario_command(rest)?),
|
||
["why", rest @ ..] => {
|
||
// The system n of the summary, else the monitored one.
|
||
let i = match rest.first() {
|
||
Some(n) => n.parse::<usize>().ok().and_then(|n| n.checked_sub(1)).ok_or("/airdef why <номер>")?,
|
||
None => self.monitor.ok_or("/airdef why <номер> (или откройте монитор K)")?,
|
||
};
|
||
if i >= self.sim.sams.len() {
|
||
return Err("Нет такой техники".into());
|
||
}
|
||
for c in self.sim.why(i) {
|
||
say(&format!("{} {}", if c.ok { "+" } else { "-" }, c.text));
|
||
}
|
||
None
|
||
}
|
||
["raid"] => {
|
||
self.launch_wave(&mut out)?;
|
||
None
|
||
}
|
||
["sites"] => {
|
||
// The launch sites the radars have found, and the strike missiles (#101).
|
||
let p = player().ok_or("Нет игрока")?;
|
||
for l in self.sim.site_lines(DVec3::new(p.x, p.y, p.z)) {
|
||
say(&l);
|
||
}
|
||
None
|
||
}
|
||
["ground-stock", n, count] => {
|
||
let i = n.parse::<usize>().ok().and_then(|v| v.checked_sub(1)).ok_or("/airdef ground-stock <номер склада> <количество>")?;
|
||
let count = count.parse::<u32>().ok().filter(|v| *v <= 10000).ok_or("Количество: 0..10000")?;
|
||
let depot = self.sim.sams.get_mut(i).ok_or("Нет такого склада")?;
|
||
if depot.kind != SamKind::Depot || !depot.alive() { return Err("Нужен действующий склад".into()); }
|
||
depot.ground_stock = count;
|
||
self.dirty = true;
|
||
Some(format!("Sandbox: задан начальный запас склада №{}: RM48U {}", i + 1, count))
|
||
}
|
||
["ground-load", n] => {
|
||
let i = n.parse::<usize>().ok().and_then(|v| v.checked_sub(1)).ok_or("/airdef ground-load <номер комплекса>")?;
|
||
let message = self.sim.load_ground_round(i)?;
|
||
self.dirty = true;
|
||
Some(message)
|
||
}
|
||
["ground-unload", n] => {
|
||
let i = n.parse::<usize>().ok().and_then(|v| v.checked_sub(1)).ok_or("/airdef ground-unload <номер комплекса>")?;
|
||
let message = self.sim.unload_ground_round(i)?;
|
||
self.dirty = true;
|
||
Some(message)
|
||
}
|
||
["ground-cancel", n] => {
|
||
let i = n.parse::<usize>().ok().and_then(|v| v.checked_sub(1)).ok_or("/airdef ground-cancel <номер комплекса>")?;
|
||
let message = self.sim.cancel_ground_request(i)?;
|
||
self.dirty = true;
|
||
Some(message)
|
||
}
|
||
["strike", n] => {
|
||
// A manual order: the simulation validates availability; player position is no launcher.
|
||
let p = player().ok_or("Нет игрока")?;
|
||
let id = n.parse::<u32>().map_err(|_| "/airdef strike <номер ПУ из /airdef sites>")?;
|
||
let said = self.sim.order_strike(id, DVec3::new(p.x, p.y, p.z), &mut out)?;
|
||
// The stock went down: the durable state must not forget it (#113).
|
||
self.dirty = true;
|
||
Some(said)
|
||
}
|
||
["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())
|
||
}
|
||
["truth", v @ ("on" | "off")] => {
|
||
self.sim.truth = *v == "on";
|
||
Some(format!("Истинные данные на радаре: {} (боевую логику не меняют)", if self.sim.truth { "вкл" } else { "выкл" }))
|
||
}
|
||
["damage", v @ ("on" | "off")] => {
|
||
self.sim.damage = *v == "on";
|
||
self.dirty = true;
|
||
Some(format!("Разрушения: {}", if self.sim.damage { "вкл" } else { "выкл" }))
|
||
}
|
||
["doctrine", rest @ ..] => Some(self.doctrine_command(rest)?),
|
||
["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(", ") }));
|
||
}
|
||
say(&format!(
|
||
"Последний шанс: {} (комплекс стреляет и по классу вне ролей, если цель вот-вот попадёт; /airdef lastchance on|off)",
|
||
if self.sim.last_chance { "вкл" } else { "выкл" }
|
||
));
|
||
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())
|
||
}
|
||
["lastchance", v @ ("on" | "off")] => {
|
||
self.sim.last_chance = *v == "on";
|
||
self.dirty = true;
|
||
Some(if self.sim.last_chance {
|
||
"Последний шанс: вкл — комплекс стреляет и по классу вне ролей, если цель вот-вот попадёт".into()
|
||
} else {
|
||
"Последний шанс: выкл — комплексы стреляют только по своим ролям".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,
|
||
self.sim.crashes,
|
||
self.sim.strikes.fired,
|
||
self.sim.strikes.destroyed,
|
||
self.sim.strikes.stunned,
|
||
self.sim.strikes.missed,
|
||
self.sim.strikes.shot_down,
|
||
self.ground.world.text()
|
||
)),
|
||
_ => return Err(help()),
|
||
};
|
||
self.emit(out);
|
||
Ok(reply)
|
||
}
|
||
}
|
||
|
||
horizon_mod_sdk::export_mod!(AirDef);
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
#[test]
|
||
fn battery_menu_presets_leave_existing_catalog_indices_intact() {
|
||
use super::*;
|
||
assert_eq!(sim::catalog::INVENTORY[0], "airdef:designator");
|
||
assert_eq!(sim::catalog::UNITS[3].kind, SamKind::S400);
|
||
assert_eq!(sim::catalog::UNITS[4].kind, SamKind::S500);
|
||
assert_eq!(sim::catalog::UNITS[10].kind, SamKind::Radar);
|
||
for (key, _) in BATTERY_DEPLOY {
|
||
assert!(deploy_configuration(key).is_some());
|
||
}
|
||
for kind in SamKind::ALL {
|
||
let (actual, mode, role) = deploy_configuration(kind.key()).unwrap();
|
||
assert_eq!(actual, kind);
|
||
assert_eq!(mode, sim::battery::SamMode::Integrated);
|
||
assert_eq!(role, sim::battery::RadarRole::Multifunction);
|
||
}
|
||
}
|
||
|
||
use super::*;
|
||
|
||
fn test_mod() -> AirDef {
|
||
AirDef {
|
||
sim: Sim::new(1),
|
||
ground: Ground::default(),
|
||
dirty: false,
|
||
next_save: 0,
|
||
hud_shown: false,
|
||
monitor: None,
|
||
monitor_shown: false,
|
||
grid: false,
|
||
grid_ids: Vec::new(),
|
||
wave: wave::WaveConfig::default(),
|
||
presentation: presentation::Session::default(),
|
||
block_log: None,
|
||
time_view: false,
|
||
film_prev: None,
|
||
smoke: Default::default(),
|
||
far: true,
|
||
acoustics: None,
|
||
moving: None,
|
||
hd: false,
|
||
world: None,
|
||
health_mark: 0,
|
||
menu: None,
|
||
listener: DVec3::ZERO,
|
||
punch: 0.0,
|
||
pending: Vec::new(),
|
||
engines: engines::Engines::default(),
|
||
engine_gen: u32::MAX,
|
||
engines_replay: false,
|
||
model_ids: std::collections::HashMap::new(),
|
||
model_generation: u32::MAX,
|
||
by_id: Vec::new(),
|
||
map: map::MapUi::default(),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_return_reservation_lost_with_the_launcher_keeps_a_loadable_save() {
|
||
let mut game = test_mod();
|
||
let mut sam = Sam::new(100, SamKind::S400, DVec3::ZERO, 0.0);
|
||
sam.ground_rounds = 1;
|
||
sam.missiles = 3;
|
||
sam.ground_return = true;
|
||
sam.comps.0[sim::Part::Launcher as usize] = 0.0;
|
||
sam.fit_cells();
|
||
game.sim.sams.push(sam);
|
||
let mut restored = test_mod();
|
||
restored.apply_state(&game.state_text(false, false)).unwrap();
|
||
assert_eq!(restored.sim.sams[0].ground_rounds, 0);
|
||
assert!(!restored.sim.sams[0].ground_return);
|
||
}
|
||
|
||
#[test]
|
||
fn return_round_drives_and_survives_both_state_round_trips() {
|
||
struct Flat;
|
||
impl sim::world::WorldSource for Flat {
|
||
fn solid(&self, _: i32, y: i32, _: i32) -> Option<bool> { Some(y < 64) }
|
||
}
|
||
let mut game = test_mod();
|
||
for (kind, x) in [(SamKind::Depot, 0.0), (SamKind::S400, 160.0), (SamKind::Tzm, 0.0)] {
|
||
let id = game.sim.id();
|
||
game.sim.sams.push(Sam::new(id, kind, DVec3::new(x, 64.0, 0.0), 0.0));
|
||
}
|
||
game.sim.sams[1].ground_rounds = 1;
|
||
game.sim.sams[1].missiles = 3;
|
||
game.sim.unload_ground_round(1).unwrap();
|
||
assert!(game.sim.sams[1].ground_return);
|
||
assert!(game.sim.load_ground_round(1).is_err());
|
||
let saved = game.state_text(false, false);
|
||
let mut restored = test_mod();
|
||
restored.apply_state(&saved).unwrap();
|
||
game = restored;
|
||
assert!(game.sim.sams[1].ground_return);
|
||
let mut out = Out::default();
|
||
let mut picked = false;
|
||
let mut far: f64 = 0.0;
|
||
for _ in 0..12000 {
|
||
let now = game.sim.tick;
|
||
let cols = game.ground.take_wanted().into_iter().map(|(x, z)| (x, z, 64)).collect();
|
||
game.ground.answer(cols, now);
|
||
let sections = game.ground.world.take_wanted(now);
|
||
game.ground.world.serve(&Flat, sections, now);
|
||
game.sim.step(&mut game.ground, None, &mut out);
|
||
far = far.max(game.sim.sams[2].pos.x);
|
||
if !picked && game.sim.sams[2].return_cargo {
|
||
assert_eq!((game.sim.sams[1].ground_rounds, game.sim.sams[0].ground_stock), (0, 0));
|
||
let saved = game.state_text(false, false);
|
||
let mut restored = test_mod();
|
||
restored.apply_state(&saved).unwrap();
|
||
game = restored;
|
||
assert!(game.sim.sams[2].return_cargo);
|
||
assert_eq!(game.sim.sams[2].ground_stock, 1);
|
||
picked = true;
|
||
}
|
||
if picked && game.sim.sams[0].ground_stock == 1 { break; }
|
||
out = Out::default();
|
||
}
|
||
assert!(picked && far > 140.0);
|
||
assert_eq!((game.sim.sams[0].ground_stock, game.sim.sams[1].ground_rounds, game.sim.sams[2].ground_stock), (1, 0, 0));
|
||
assert!(!game.sim.sams[2].return_cargo);
|
||
}
|
||
|
||
#[test]
|
||
fn delivery_request_and_cargo_survive_full_state_round_trip() {
|
||
struct Flat;
|
||
impl sim::world::WorldSource for Flat {
|
||
fn solid(&self, _: i32, y: i32, _: i32) -> Option<bool> { Some(y < 64) }
|
||
}
|
||
let mut before = test_mod();
|
||
for (kind, x) in [(SamKind::Depot, 0.0), (SamKind::S400, 160.0), (SamKind::Tzm, 30.0)] {
|
||
let id = before.sim.id();
|
||
before.sim.sams.push(Sam::new(id, kind, DVec3::new(x, 64.0, 0.0), 0.0));
|
||
}
|
||
before.sim.sams[1].ground_request = true;
|
||
before.sim.sams[1].radar_on = false;
|
||
before.sim.sams[1].ground_rounds = 1;
|
||
before.sim.sams[1].missiles = 3;
|
||
before.sim.sams[2].ground_stock = 1;
|
||
before.sim.order_move(2, DVec3::new(100.0, 64.0, 0.0));
|
||
let text = before.state_text(false, false);
|
||
let mut after = test_mod();
|
||
after.apply_state(&text).unwrap();
|
||
assert_eq!((after.sim.sams[0].ground_stock, after.sim.sams[1].ground_rounds, after.sim.sams[1].missiles), (0, 1, 3));
|
||
assert!(after.sim.sams[1].ground_request);
|
||
assert!(!after.sim.sams[1].radar_on);
|
||
assert_eq!(after.sim.sams[2].ground_stock, 1);
|
||
assert!(after.sim.sams[2].moving());
|
||
let mut out = Out::default();
|
||
for _ in 0..6000 {
|
||
let now = after.sim.tick;
|
||
let cols = after.ground.take_wanted().into_iter().map(|(x, z)| (x, z, 64)).collect();
|
||
after.ground.answer(cols, now);
|
||
let sections = after.ground.world.take_wanted(now);
|
||
after.ground.world.serve(&Flat, sections, now);
|
||
after.sim.step(&mut after.ground, None, &mut out);
|
||
if after.sim.sams[0].air_48n6_stock == 1 { break; }
|
||
out = Out::default();
|
||
}
|
||
assert_eq!((after.sim.sams[1].ground_rounds, after.sim.sams[1].missiles), (2, 2));
|
||
assert!(!after.sim.sams[1].ground_request);
|
||
assert_eq!((after.sim.sams[0].air_48n6_stock, after.sim.sams[2].ground_stock, after.sim.sams[2].air_48n6_stock), (1, 0, 0));
|
||
}
|
||
|
||
/// #83: while an export records no other replay or film replaces it; after it, they may.
|
||
#[test]
|
||
fn typed_ammunition_changes_mark_the_state_dirty() {
|
||
let mut sim = Sim::new(1);
|
||
sim.sams.push(Sam::new(1, SamKind::S400, DVec3::ZERO, 0.0));
|
||
let before = durable_mark(&sim);
|
||
sim.sams[0].ground_rounds = 1;
|
||
assert_ne!(durable_mark(&sim), before);
|
||
let before = durable_mark(&sim);
|
||
sim.sams[0].ground_stock = 1;
|
||
assert_ne!(durable_mark(&sim), before);
|
||
}
|
||
|
||
#[test]
|
||
fn battery_configuration_and_spent_cells_change_durable_mark() {
|
||
let mut sim = Sim::new(1);
|
||
sim.sams.push(Sam::new(1, SamKind::S400, DVec3::ZERO, 0.0));
|
||
let before = durable_mark(&sim);
|
||
sim.sams[0].set_mode(sim::battery::SamMode::LauncherOnly);
|
||
assert_ne!(durable_mark(&sim), before);
|
||
let before = durable_mark(&sim);
|
||
sim.sams[0].spent_cells = 1;
|
||
assert_ne!(durable_mark(&sim), before);
|
||
sim.sams.push(Sam::new(2, SamKind::Radar, DVec3::ZERO, 0.0));
|
||
let before = durable_mark(&sim);
|
||
sim.sams[1].set_radar_role(sim::battery::RadarRole::Search);
|
||
assert_ne!(durable_mark(&sim), before);
|
||
}
|
||
|
||
#[test]
|
||
fn nothing_replaces_a_running_export() {
|
||
assert!(switch_allowed(true).is_err());
|
||
assert!(switch_allowed(false).is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn delayed_replay_audio_uses_recording_time_and_is_dropped_after_seek_back() {
|
||
let ctx = presentation::Context::playback(
|
||
presentation::Mode::Replay,
|
||
7,
|
||
None,
|
||
90_000,
|
||
900,
|
||
20.5,
|
||
None,
|
||
0.25,
|
||
DVec3::ZERO,
|
||
true,
|
||
);
|
||
let clock = ctx.sound_clock();
|
||
let due = clock.deadline_after(5);
|
||
let pending = PendingSound {
|
||
due,
|
||
generation: ctx.generation,
|
||
created_at: clock,
|
||
name: "test".into(),
|
||
at: DVec3::ZERO,
|
||
volume: 1.0,
|
||
pitch: 1.0,
|
||
};
|
||
|
||
assert_eq!(due, 25.5);
|
||
assert!(!presentation::Clock::Recording(25.25).has_reached(due));
|
||
assert!(!clock.has_reached(due), "slow playback has not advanced the delay yet");
|
||
assert!(pending.invalidated_by(ctx.generation, presentation::Clock::Recording(19.0)));
|
||
assert!(pending.invalidated_by(ctx.generation + 1, clock));
|
||
assert!(!pending.invalidated_by(ctx.generation, presentation::Clock::Recording(20.5)));
|
||
}
|
||
|
||
#[test]
|
||
fn shown_effects_follow_the_recording_clock_not_the_combat_clock() {
|
||
let live_blast = sim::Blast { id: 1, at: DVec3::ZERO, size: 4.0, start: 900, life: 60 };
|
||
let mut rec = sim::record::Recording::blank(100);
|
||
rec.events.push(sim::record::Event {
|
||
at: 12,
|
||
pos: DVec3::X,
|
||
kind: sim::record::EventKind::Hit { drone: 1, kind: DroneKind::Geran3, power: 8, object: None, sam: None },
|
||
});
|
||
let ctx = presentation::Context::playback(
|
||
presentation::Mode::Replay,
|
||
5,
|
||
Some(Some("w".into())),
|
||
10_000,
|
||
10_001,
|
||
12.5,
|
||
Some(13000),
|
||
0.3,
|
||
DVec3::Z,
|
||
true,
|
||
);
|
||
let record_scene = scene::Snapshot::at_context(&ctx, scene::Source::Recorded(&rec));
|
||
let shown = Shown::from_context(&ctx, &record_scene);
|
||
assert!(shown.replay);
|
||
assert_eq!(shown.now, 12.5);
|
||
assert_eq!(shown.blasts.len(), 1);
|
||
assert_eq!(shown.blasts[0].id, 0x4000_0000);
|
||
assert!((shown.hold - 0.7).abs() < 1e-6);
|
||
|
||
let map = presentation::Context::playback(
|
||
presentation::Mode::Replay,
|
||
5,
|
||
Some(Some("w".into())),
|
||
10_020,
|
||
10_002,
|
||
20.0,
|
||
Some(13000),
|
||
1.0,
|
||
DVec3::Z,
|
||
false,
|
||
);
|
||
let mut live = Sim::new(1);
|
||
live.tick = 10_002;
|
||
live.blasts.push(live_blast);
|
||
let map_scene = scene::Snapshot::at_context(&map, scene::Source::Live(&live));
|
||
let shown_map = Shown::from_context(&map, &map_scene);
|
||
assert!(!shown_map.replay);
|
||
assert_eq!(shown_map.now, 10_002.0);
|
||
assert_eq!(shown_map.blasts[0].id, live_blast.id);
|
||
}
|
||
|
||
#[test]
|
||
fn strike_stock_and_refill_change_the_durable_mark() {
|
||
let mut sim = Sim::new(7);
|
||
let full = durable_mark(&sim);
|
||
sim.strikes.stock -= 1;
|
||
assert_ne!(durable_mark(&sim), full, "spending a missile is not saved");
|
||
|
||
sim.strikes.progress = sim::strike::TUNE.resupply - 1;
|
||
let before = durable_mark(&sim);
|
||
let (mut ground, mut out) = (sim::Ground::default(), sim::Out::default());
|
||
sim.step(&mut ground, None, &mut out);
|
||
assert_eq!(sim.strikes.stock, 3);
|
||
assert_ne!(durable_mark(&sim), before, "refilling a missile is not saved");
|
||
|
||
let checkpoint = durable_mark(&sim);
|
||
sim.strikes.progress = 1;
|
||
assert_eq!(durable_mark(&sim), checkpoint, "progress inside one checkpoint saves every tick");
|
||
sim.strikes.progress = sim::strike::TUNE.progress_save;
|
||
assert_ne!(durable_mark(&sim), checkpoint, "a refill checkpoint is not saved");
|
||
}
|
||
}
|