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