Raid replays: recording, raid map, event clips, full replay, highlight reel
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -82,10 +82,23 @@ CI: `.gitea/workflows/build.yml` на каждый пуш собирает мо
|
||||
самые занятые (стреляют, держат захват, сопровождают, горят), раз в 2 секунды; комплекс с монитора K — всегда.
|
||||
Повторное J закрывает.
|
||||
|
||||
Клавиши N, K и J можно переназначить в «Настройки → Моды».
|
||||
**Повторы.** Каждый налёт записывается сам: с первой цели в небе до момента, когда небо 5 с чисто
|
||||
(хранятся 3 последних). Меню N → «Повторы…» или клавиша **R**:
|
||||
- **карта налёта** — вид сверху: комплексы и их зоны, объекты, треки целей (красные), ложных целей (серые) и
|
||||
перехватчиков (жёлтые), сбития (x), прилёты, шкала времени с событиями; время идёт само, колесо мыши перематывает;
|
||||
- **повтор момента** — клик по событию в списке: «призраки» дронов и ракет снова летят в мире, камера идёт за
|
||||
целью, потом за перехватчиком (или смотрит из пушки, со стороны на прилёт), в момент сбития время замедляется;
|
||||
- **полный повтор** — весь налёт, камера-режиссёр сама выбирает, за чем следить; колесо — скорость (×0.5–×16);
|
||||
- **лучшие моменты** — нарезка до 8 самых интересных событий (перехват баллистики и гиперзвука, поражения
|
||||
объектов, потерянные комплексы, разделение «Орешника») с титрами и замедлением; колесо листает моменты.
|
||||
|
||||
Повтор идёт на весь экран с леттербоксом; звук слышен так, как его слышала бы камера. R — выход.
|
||||
|
||||
Клавиши N, K, J и R можно переназначить в «Настройки → Моды».
|
||||
|
||||
Команды:
|
||||
- `/airdef wave <тип> [кол-во] [дальность]` — налёт на ближайшую цель. Типы: `shahed`, `geran3`, `lancet`, `gerbera`, `kh101`, `kalibr`, `kh22`, `zircon`, `iskander`, `kinzhal`, `oreshnik` и `mix` (комбинированный удар двумя секторами: «Герберы», шахеды, Герани-3, Х-101, «Калибры», Х-22, Циркон, «Искандер», «Кинжал», при 30+ — «Орешник»);
|
||||
- `/airdef replay [map|full|reel|stop]` — повтор последнего налёта;
|
||||
- `/airdef raid` — налёт, настроенный в меню; `/airdef target here` — отметить объект под ногами; `/airdef repair` — ремонт;
|
||||
- `/airdef roles` — показать, по каким классам целей работает каждый комплекс; `/airdef roles <patriot|gepard|pantsir|s400|s500|all> <классы|default>` — задать (классы через запятую: `drone`, `jet`, `cruise`, `supersonic`, `ballistic` или `all`), например `/airdef roles s400 cruise,ballistic`;
|
||||
- `/airdef deploy <patriot|gepard|pantsir|s400|s500>` — поставить комплекс в 8 блоках перед собой;
|
||||
|
||||
+132
-5
@@ -15,6 +15,7 @@ use horizon_mod_sdk::{
|
||||
mod monitor;
|
||||
mod panel;
|
||||
mod radar;
|
||||
mod replay;
|
||||
mod sim;
|
||||
mod wave;
|
||||
use sim::{Class, DroneKind, Ground, Out, Sam, SamKind, Sim};
|
||||
@@ -53,6 +54,8 @@ struct AirDef {
|
||||
grid_ids: Vec<u32>,
|
||||
/// The raid the wave menu orders.
|
||||
wave: wave::WaveConfig,
|
||||
/// A replay playing (it takes the screen and the mouse wheel).
|
||||
replay: Option<replay::Player>,
|
||||
/// The menu's page while it is open.
|
||||
menu: Option<Page>,
|
||||
/// Where the player is, for the sounds' delay and far variants.
|
||||
@@ -81,6 +84,8 @@ enum Page {
|
||||
WaveGo,
|
||||
/// Fire, repair, effects, damage.
|
||||
More,
|
||||
/// The last raid's events and its replays.
|
||||
Replays,
|
||||
}
|
||||
|
||||
const MENU_KINDS: u32 = 1;
|
||||
@@ -99,6 +104,11 @@ 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_CLASS: u32 = 100;
|
||||
const BTN_ALL: u32 = 120;
|
||||
const BTN_DEFAULT: u32 = 121;
|
||||
@@ -319,8 +329,8 @@ impl AirDef {
|
||||
|
||||
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 covers the screen: the other panels wait under it.
|
||||
if self.grid || (air.is_empty() && self.sim.sams.is_empty() && self.sim.missiles.is_empty()) {
|
||||
// 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();
|
||||
@@ -402,6 +412,39 @@ impl AirDef {
|
||||
}
|
||||
|
||||
impl AirDef {
|
||||
/// Plays the last recorded raid: "map", "full", "reel" or (with `event`) a clip.
|
||||
fn start_replay(&mut self, what: &str, event: Option<usize>) -> Result<(), String> {
|
||||
let n = self.sim.replays.len();
|
||||
if n == 0 {
|
||||
return Err("Повторов пока нет: запишется первый же налёт (когда небо очистится)".into());
|
||||
}
|
||||
let rec = &self.sim.replays[n - 1];
|
||||
let mode = match (what, event) {
|
||||
(_, Some(i)) if i < rec.events.len() => replay::Player::event_clip(rec, i),
|
||||
("full", _) => replay::Mode::Full,
|
||||
("reel", _) => {
|
||||
let list = replay::reel(rec);
|
||||
if list.is_empty() {
|
||||
return Err("В этом налёте нечего показать".into());
|
||||
}
|
||||
replay::Mode::Clips { list, at: 0, reel: true }
|
||||
}
|
||||
_ => replay::Mode::Map,
|
||||
};
|
||||
self.replay = Some(replay::Player::new(n - 1, mode, &self.sim));
|
||||
self.grid = false;
|
||||
input::claim_wheel(true);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn stop_replay(&mut self) {
|
||||
self.replay = None;
|
||||
input::claim_wheel(false);
|
||||
render::set_hud(&[]);
|
||||
render::set_views(&[]);
|
||||
self.monitor_shown = false;
|
||||
}
|
||||
|
||||
/// What a raid strikes: the marked objects, else where the player stands.
|
||||
fn objects(&self, player: DVec3) -> Vec<DVec3> {
|
||||
let live: Vec<DVec3> = self
|
||||
@@ -487,8 +530,31 @@ impl AirDef {
|
||||
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 {
|
||||
@@ -561,7 +627,7 @@ impl AirDef {
|
||||
}
|
||||
}
|
||||
|
||||
const HELP: &str = "/airdef menu | monitor | grid | raid | repair | target here | give | deploy <комплекс> | wave <тип|mix> [кол-во] [дальность] | clear | targets clear | damage on|off | shader on|off | hold on|off | roles [комплекс классы] | stats";
|
||||
const HELP: &str = "/airdef menu | monitor | grid | replay [map|full|reel|stop] | raid | repair | target here | give | deploy <комплекс> | wave <тип|mix> [кол-во] [дальность] | clear | targets clear | damage on|off | shader on|off | hold on|off | roles [комплекс классы] | stats";
|
||||
|
||||
impl Mod for AirDef {
|
||||
fn init() -> Result<(Self, Registration), String> {
|
||||
@@ -576,6 +642,7 @@ impl Mod for AirDef {
|
||||
grid: false,
|
||||
grid_ids: Vec::new(),
|
||||
wave: wave::WaveConfig::default(),
|
||||
replay: None,
|
||||
menu: None,
|
||||
listener: DVec3::ZERO,
|
||||
pending: Vec::new(),
|
||||
@@ -583,6 +650,7 @@ impl Mod for AirDef {
|
||||
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");
|
||||
me.load();
|
||||
input::claim_items(&ITEMS.map(String::from));
|
||||
render::set_post(include_str!("../shaders/effects.wgsl"));
|
||||
@@ -598,6 +666,20 @@ impl Mod for AirDef {
|
||||
Event::KeyDown(k) if k == "menu" => self.open_menu(Page::Main),
|
||||
Event::KeyDown(k) if k == "monitor" => self.cycle_monitor(),
|
||||
Event::KeyDown(k) if k == "grid" => self.grid = !self.grid,
|
||||
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);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
@@ -610,10 +692,24 @@ impl Mod for AirDef {
|
||||
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 monitors and the cameras they show.
|
||||
if self.grid {
|
||||
// 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();
|
||||
@@ -712,6 +808,30 @@ impl Mod for AirDef {
|
||||
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;
|
||||
@@ -809,6 +929,13 @@ impl Mod for AirDef {
|
||||
}
|
||||
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
|
||||
|
||||
@@ -0,0 +1,629 @@
|
||||
//! Replays of recorded raids: the raid's map (every track over time), a clip
|
||||
//! of any event, the whole raid, and a highlight reel of the best moments.
|
||||
//! Clips are filmed: ghosts of the drones and interceptors fly again in the
|
||||
//! world and a director's camera (a full-screen camera view) follows them —
|
||||
//! behind the drone, then behind the interceptor or from the side — slowing
|
||||
//! time round the moment itself.
|
||||
use crate::panel::distance;
|
||||
use crate::sim::record::{EventKind, Recording, What};
|
||||
use crate::sim::{Class, DroneKind, Out, Sim};
|
||||
use glam::DVec3;
|
||||
use horizon_mod_sdk::render::{CameraView, FillShape, Point, QuadShape, Rect, Shape, TextShape, ViewShape};
|
||||
|
||||
/// Ghost models' ids, clear of the live ones.
|
||||
const GHOSTS: u32 = 0x5000_0000;
|
||||
/// The camera view's id (a new one each cut, so the game doesn't sweep between shots).
|
||||
const VIEW: u32 = 0x7700_0000;
|
||||
|
||||
pub enum Mode {
|
||||
/// The raid from above, its tracks drawn as time runs (the wheel scrubs).
|
||||
Map,
|
||||
/// The whole raid filmed, the director choosing what to follow (the wheel sets the speed).
|
||||
Full,
|
||||
/// Clips one after another (the wheel skips): one event, or the highlight reel.
|
||||
Clips { list: Vec<Clip>, at: usize, reel: bool },
|
||||
}
|
||||
|
||||
pub struct Clip {
|
||||
pub event: usize,
|
||||
from: f64,
|
||||
to: f64,
|
||||
}
|
||||
|
||||
pub struct Player {
|
||||
/// Which of the sim's recordings.
|
||||
pub rec: usize,
|
||||
pub mode: Mode,
|
||||
t: f64,
|
||||
speed: f64,
|
||||
/// The director's current shot (event, shot) and the view id it films with.
|
||||
shot: (usize, u8),
|
||||
view: u32,
|
||||
/// Ticks of black left after a cut, of the title card left.
|
||||
fade: u32,
|
||||
card: u32,
|
||||
/// The camera where an interceptor met its target: it stays there after.
|
||||
held: Option<DVec3>,
|
||||
/// The eye this tick (sounds are heard from it).
|
||||
eye: DVec3,
|
||||
look: DVec3,
|
||||
fov: f32,
|
||||
/// The last tick whose events made their sounds.
|
||||
heard: f64,
|
||||
pub done: bool,
|
||||
}
|
||||
|
||||
fn fill(x: f32, y: f32, w: f32, h: f32, color: u32) -> Shape {
|
||||
Shape::Fill(FillShape { rect: Rect { x, y, w, h }, color })
|
||||
}
|
||||
fn text(t: impl Into<String>, x: f32, y: f32, color: u32, centered: bool) -> Shape {
|
||||
Shape::Text(TextShape { text: t.into(), at: Point { x, y }, color, centered, shadow: true })
|
||||
}
|
||||
fn line(a: (f32, f32), b: (f32, f32), w: f32, color: u32) -> Shape {
|
||||
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
|
||||
let len = (dx * dx + dy * dy).sqrt().max(0.01);
|
||||
let (nx, ny) = (-dy / len * w * 0.5, dx / len * w * 0.5);
|
||||
let p = |x: f32, y: f32| Point { x, y };
|
||||
Shape::Quad(QuadShape { corners: (p(a.0 + nx, a.1 + ny), p(b.0 + nx, b.1 + ny), p(b.0 - nx, b.1 - ny), p(a.0 - nx, a.1 - ny)), color })
|
||||
}
|
||||
fn clock(ticks: f64) -> String {
|
||||
let s = (ticks / 20.0).max(0.0);
|
||||
format!("{:02}:{:04.1}", (s / 60.0) as u32, s % 60.0)
|
||||
}
|
||||
|
||||
/// What an event was, in a line.
|
||||
pub fn title(rec: &Recording, i: usize) -> String {
|
||||
let e = &rec.events[i];
|
||||
match e.kind {
|
||||
EventKind::Kill { kind, sam_kind, sam_index, missile, .. } => {
|
||||
let how = if missile.is_some() { "ракетой" } else { "огнём пушек" };
|
||||
format!("{} №{} сбивает «{}» {how}", sam_kind.name(), sam_index + 1, kind.spec().name)
|
||||
}
|
||||
EventKind::Hit { kind, object: Some(o), .. } => format!("«{}» поражает объект №{}", kind.spec().name, o + 1),
|
||||
EventKind::Hit { kind, sam: Some((sk, si)), .. } => format!("«{}» бьёт по {} №{}", kind.spec().name, sk.name(), si + 1),
|
||||
EventKind::Hit { kind, .. } => format!("Прилёт: «{}»", kind.spec().name),
|
||||
EventKind::SamLost { kind, index, .. } => format!("{} №{} уничтожен", kind.name(), index + 1),
|
||||
EventKind::Split { .. } => "«Орешник»: разделение боевых блоков".into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A short line for the event list: its time and what it was.
|
||||
pub fn row(rec: &Recording, i: usize) -> String {
|
||||
let e = &rec.events[i];
|
||||
let what = match e.kind {
|
||||
EventKind::Kill { kind, sam_kind, sam_index, missile, .. } => {
|
||||
format!("{}-{} > {}{}", sam_kind.name(), sam_index + 1, kind.spec().name, if missile.is_none() { " (пушки)" } else { "" })
|
||||
}
|
||||
EventKind::Hit { kind, object: Some(o), .. } => format!("{} > объект {}", kind.spec().name, o + 1),
|
||||
EventKind::Hit { kind, sam: Some((sk, si)), .. } => format!("{} > {}-{}", kind.spec().name, sk.name(), si + 1),
|
||||
EventKind::Hit { kind, .. } => format!("{}: прилёт", kind.spec().name),
|
||||
EventKind::SamLost { kind, index, .. } => format!("{}-{} уничтожен", kind.name(), index + 1),
|
||||
EventKind::Split { .. } => "Орешник: разделение".into(),
|
||||
};
|
||||
format!("{} {what}", clock(e.at as f64))
|
||||
}
|
||||
|
||||
/// How worth watching an event is: the reel takes the best.
|
||||
fn interest(rec: &Recording, i: usize) -> f64 {
|
||||
let e = &rec.events[i];
|
||||
match e.kind {
|
||||
EventKind::Kill { kind, missile, .. } => {
|
||||
let spec = kind.spec();
|
||||
let class = match spec.class {
|
||||
Class::Ballistic => 10.0,
|
||||
Class::Supersonic => 7.0,
|
||||
Class::Cruise => 5.0,
|
||||
Class::Jet => 4.0,
|
||||
Class::Drone => 2.0,
|
||||
};
|
||||
let rare = match kind {
|
||||
DroneKind::Kinzhal | DroneKind::Oreshnik | DroneKind::Zircon => 4.0,
|
||||
DroneKind::OreshnikSub => -6.0,
|
||||
_ => 0.0,
|
||||
};
|
||||
// A kill close to what it was going for.
|
||||
let close = rec.objects.iter().chain(rec.sams.iter().map(|s| &s.2)).any(|o| o.distance(e.pos) < 40.0);
|
||||
class + rare + if spec.decoy { -3.0 } else { 0.0 } + if missile.is_none() { 1.0 } else { 0.0 } + if close { 3.0 } else { 0.0 }
|
||||
}
|
||||
EventKind::Hit { power, object, sam, .. } => {
|
||||
power as f64 * 1.5 + if object.is_some() { 6.0 } else if sam.is_some() { 5.0 } else { 0.0 }
|
||||
}
|
||||
EventKind::SamLost { .. } => 12.0,
|
||||
EventKind::Split { drone } => {
|
||||
// The bus's split, not each block's.
|
||||
let first = rec.events.iter().position(|o| matches!(o.kind, EventKind::Split { .. }));
|
||||
if first == Some(i) || rec.track(drone).is_some_and(|t| t.what == What::Drone(DroneKind::Oreshnik)) { 11.0 } else { 0.0 }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The clip of event `i`: from a while before it to a little after.
|
||||
fn clip(rec: &Recording, i: usize) -> Clip {
|
||||
let at = rec.events[i].at as f64;
|
||||
let (before, after) = match rec.events[i].kind {
|
||||
EventKind::Kill { .. } => (140.0, 50.0),
|
||||
EventKind::Hit { .. } => (160.0, 60.0),
|
||||
EventKind::SamLost { .. } => (80.0, 90.0),
|
||||
EventKind::Split { .. } => (40.0, 170.0),
|
||||
};
|
||||
Clip { event: i, from: (at - before).max(0.0), to: (at + after).min(rec.len as f64) }
|
||||
}
|
||||
|
||||
/// The best moments, a few seconds apart, in order.
|
||||
pub fn reel(rec: &Recording) -> Vec<Clip> {
|
||||
let mut best: Vec<(f64, usize)> = (0..rec.events.len()).map(|i| (interest(rec, i), i)).filter(|b| b.0 >= 2.0).collect();
|
||||
best.sort_by(|a, b| b.0.total_cmp(&a.0));
|
||||
let mut chosen: Vec<usize> = Vec::new();
|
||||
for (_, i) in best {
|
||||
if chosen.len() >= 8 {
|
||||
break;
|
||||
}
|
||||
let at = rec.events[i].at as i64;
|
||||
if chosen.iter().all(|&c| (rec.events[c].at as i64 - at).abs() > 90) {
|
||||
chosen.push(i);
|
||||
}
|
||||
}
|
||||
chosen.sort_by_key(|&i| rec.events[i].at);
|
||||
chosen.into_iter().map(|i| clip(rec, i)).collect()
|
||||
}
|
||||
|
||||
impl Player {
|
||||
pub fn new(rec: usize, mode: Mode, sim: &Sim) -> Self {
|
||||
let start = match &mode {
|
||||
Mode::Clips { list, .. } => list.first().map_or(0.0, |c| c.from),
|
||||
_ => 0.0,
|
||||
};
|
||||
let reel = matches!(mode, Mode::Clips { reel: true, .. });
|
||||
let speed = match mode {
|
||||
Mode::Map => 8.0,
|
||||
Mode::Full => 2.0,
|
||||
Mode::Clips { .. } => 1.0,
|
||||
};
|
||||
let _ = sim;
|
||||
Player {
|
||||
rec,
|
||||
mode,
|
||||
t: start,
|
||||
speed,
|
||||
shot: (usize::MAX, 0),
|
||||
view: VIEW,
|
||||
fade: 0,
|
||||
card: if reel { 50 } else { 0 },
|
||||
held: None,
|
||||
eye: DVec3::ZERO,
|
||||
look: DVec3::NEG_Z,
|
||||
fov: 50.0,
|
||||
heard: start,
|
||||
done: false,
|
||||
}
|
||||
}
|
||||
|
||||
/// The wheel: scrubs the map, sets the full replay's speed, skips clips.
|
||||
pub fn wheel(&mut self, steps: f32, rec: &Recording) {
|
||||
match &mut self.mode {
|
||||
Mode::Map => self.t = (self.t - steps as f64 * 60.0).clamp(0.0, rec.len as f64),
|
||||
Mode::Full => {
|
||||
const SPEEDS: [f64; 6] = [0.5, 1.0, 2.0, 4.0, 8.0, 16.0];
|
||||
let i = SPEEDS.iter().position(|s| *s >= self.speed).unwrap_or(2) as i32;
|
||||
let j = (i - steps.signum() as i32).clamp(0, SPEEDS.len() as i32 - 1);
|
||||
self.speed = SPEEDS[j as usize];
|
||||
}
|
||||
Mode::Clips { list, at, reel } => {
|
||||
let next = (*at as i32 - steps.signum() as i32).clamp(0, list.len() as i32 - 1) as usize;
|
||||
if next != *at {
|
||||
*at = next;
|
||||
self.t = list[next].from;
|
||||
self.heard = self.t;
|
||||
self.fade = 6;
|
||||
self.card = if *reel { 50 } else { 0 };
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One tick: time runs, the ghosts fly, the director films. Models and sounds go to `out`.
|
||||
pub fn tick(&mut self, sim: &Sim, listener: DVec3, out: &mut Out) {
|
||||
let Some(rec) = sim.replays.get(self.rec) else {
|
||||
self.done = true;
|
||||
return;
|
||||
};
|
||||
self.fade = self.fade.saturating_sub(1);
|
||||
if self.card > 0 {
|
||||
self.card -= 1;
|
||||
}
|
||||
// Time: slowed round the moment in clips, held still while a title card shows.
|
||||
let mut speed = self.speed;
|
||||
if let Mode::Clips { list, at, .. } = &self.mode {
|
||||
let te = rec.events[list[*at].event].at as f64;
|
||||
if (te - 14.0..te + 18.0).contains(&self.t) {
|
||||
speed = 0.3;
|
||||
}
|
||||
if self.card > 25 {
|
||||
speed = 0.0;
|
||||
}
|
||||
}
|
||||
self.t += speed;
|
||||
match &mut self.mode {
|
||||
Mode::Map | Mode::Full => {
|
||||
if self.t >= rec.len as f64 {
|
||||
self.t = rec.len as f64;
|
||||
if matches!(self.mode, Mode::Full) {
|
||||
self.done = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
Mode::Clips { list, at, reel } => {
|
||||
if self.t >= list[*at].to {
|
||||
if *at + 1 < list.len() {
|
||||
*at += 1;
|
||||
self.t = list[*at].from;
|
||||
self.heard = self.t;
|
||||
self.fade = 6;
|
||||
self.card = if *reel { 50 } else { 0 };
|
||||
} else {
|
||||
self.done = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if matches!(self.mode, Mode::Map) {
|
||||
return;
|
||||
}
|
||||
sim.draw_ghosts(rec, self.t, GHOSTS, out);
|
||||
self.direct(rec);
|
||||
// Sounds as the camera hears them: moved so the player stands where the camera is.
|
||||
let heard = |p: DVec3| listener + (p - self.eye);
|
||||
for e in rec.events.iter().filter(|e| (self.heard..self.t).contains(&(e.at as f64))) {
|
||||
let event = match e.kind {
|
||||
EventKind::Kill { .. } => "airdef:blast.air",
|
||||
EventKind::Hit { power, .. } => ["airdef:blast.air", "airdef:blast.medium", "airdef:blast.big", "airdef:blast.heavy", "airdef:blast.huge"][(power as usize).min(4)],
|
||||
EventKind::SamLost { .. } => "airdef:blast.big",
|
||||
EventKind::Split { .. } => "airdef:boom.sonic",
|
||||
};
|
||||
out.sound(event, heard(e.pos), 1.0, 1.0);
|
||||
}
|
||||
for tr in rec.tracks.iter().filter(|tr| (self.heard..self.t).contains(&(tr.first as f64))) {
|
||||
if let What::Missile(kind, _) = tr.what
|
||||
&& let Some(p) = tr.at(rec.origin, tr.first as f64)
|
||||
{
|
||||
out.sound(kind.launch_sound(), heard(p), 1.0, 1.0);
|
||||
}
|
||||
}
|
||||
self.heard = self.t;
|
||||
}
|
||||
|
||||
/// The event the camera films now, and how it shoots it: (eye, look, fov, shot).
|
||||
fn shoot(&mut self, rec: &Recording, i: usize) -> (DVec3, DVec3, f32, u8) {
|
||||
let e = rec.events[i];
|
||||
let t = self.t;
|
||||
let te = e.at as f64;
|
||||
let o = rec.origin;
|
||||
let chase = |id: u32, back: f64, up: f64| -> Option<(DVec3, DVec3)> {
|
||||
let tr = rec.track(id)?;
|
||||
let p = tr.at(o, t)?;
|
||||
let d = tr.dir(o, t);
|
||||
Some((p - d * back + DVec3::Y * up, p + d * 10.0))
|
||||
};
|
||||
let side = |at: DVec3, from: DVec3, dist: f64| {
|
||||
let across = DVec3::new(-(at - from).z, 0.0, (at - from).x).normalize_or(DVec3::X);
|
||||
at + across * dist + DVec3::Y * dist * 0.18
|
||||
};
|
||||
match e.kind {
|
||||
EventKind::Kill { drone, missile, sam, .. } => {
|
||||
let target = rec.track(drone).and_then(|tr| tr.at(o, t)).unwrap_or(e.pos);
|
||||
if t < te - 40.0 {
|
||||
if let Some((eye, look)) = chase(drone, 12.0, 4.0) {
|
||||
return (eye, look, 55.0, 0);
|
||||
}
|
||||
}
|
||||
match missile.and_then(|m| rec.track(m)) {
|
||||
Some(mt) => {
|
||||
// Behind the interceptor until it meets the target, then where it was.
|
||||
if t < te && let Some(p) = mt.at(o, t) {
|
||||
let eye = p - mt.dir(o, t) * 9.0 + DVec3::Y * 1.5;
|
||||
self.held = Some(eye);
|
||||
return (eye, target, 50.0, 1);
|
||||
}
|
||||
let eye = self.held.unwrap_or_else(|| side(e.pos, o, 40.0));
|
||||
(eye, target.lerp(e.pos, 0.5), 50.0, 1)
|
||||
}
|
||||
None => {
|
||||
// A gun kill, from the gun.
|
||||
let at = rec.sam(sam).map_or(e.pos + DVec3::Y * 20.0, |s| s.1 + DVec3::Y * 4.0);
|
||||
let dist = target.distance(at).max(1.0);
|
||||
let fov = (2.0 * (10.0 / dist).atan()).to_degrees().clamp(6.0, 60.0) as f32;
|
||||
(at, target, fov, 1)
|
||||
}
|
||||
}
|
||||
}
|
||||
EventKind::Hit { drone, .. } => {
|
||||
if t < te - 50.0 {
|
||||
if let Some((eye, look)) = chase(drone, 12.0, 4.0) {
|
||||
return (eye, look, 55.0, 0);
|
||||
}
|
||||
}
|
||||
let from = rec.track(drone).and_then(|tr| tr.at(o, te - 60.0)).unwrap_or(o);
|
||||
let eye = side(e.pos, from, 55.0);
|
||||
let look = rec.track(drone).and_then(|tr| tr.at(o, t)).filter(|_| t < te).unwrap_or(e.pos);
|
||||
(eye, look, 50.0, 1)
|
||||
}
|
||||
EventKind::SamLost { .. } => (side(e.pos, o + DVec3::new(300.0, 0.0, 0.0), 45.0), e.pos, 50.0, 0),
|
||||
EventKind::Split { .. } => {
|
||||
let ground = DVec3::new(e.pos.x, o.y, e.pos.z);
|
||||
let eye = ground + DVec3::new(170.0, 8.0, 40.0);
|
||||
let k = ((t - te) / 170.0).clamp(0.0, 1.0);
|
||||
(eye, e.pos.lerp(ground, k * 0.9), 60.0, 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Chooses the shot and moves the camera; a new shot is a cut.
|
||||
fn direct(&mut self, rec: &Recording) {
|
||||
let focus = match &self.mode {
|
||||
Mode::Clips { list, at, .. } => Some(list[*at].event),
|
||||
// The full replay follows what comes next: the next event within 6 s, else the drone
|
||||
// nearest its target.
|
||||
Mode::Full => rec
|
||||
.events
|
||||
.iter()
|
||||
.position(|e| (self.t - 30.0..self.t + 120.0).contains(&(e.at as f64)))
|
||||
.or(if self.shot.0 != usize::MAX && (rec.events[self.shot.0].at as f64) > self.t - 60.0 { Some(self.shot.0) } else { None }),
|
||||
Mode::Map => None,
|
||||
};
|
||||
let (eye, look, fov, shot) = match focus {
|
||||
Some(i) => {
|
||||
let s = self.shoot(rec, i);
|
||||
(s.0, s.1, s.2, (i, s.3))
|
||||
}
|
||||
None => {
|
||||
// The drone closest to where it is going.
|
||||
let o = rec.origin;
|
||||
let lead = rec
|
||||
.tracks
|
||||
.iter()
|
||||
.filter(|tr| matches!(tr.what, What::Drone(_)) && tr.fell.is_none_or(|f| f as f64 > self.t))
|
||||
.filter_map(|tr| tr.at(o, self.t).map(|p| (p, tr)))
|
||||
.min_by(|a, b| a.0.distance(o).total_cmp(&b.0.distance(o)));
|
||||
match lead {
|
||||
Some((p, tr)) => {
|
||||
let d = tr.dir(o, self.t);
|
||||
(p - d * 14.0 + DVec3::Y * 5.0, p + d * 10.0, 55.0, (usize::MAX, (tr.id % 251) as u8))
|
||||
}
|
||||
None => (o + DVec3::new(60.0, 30.0, 60.0), o, 60.0, (usize::MAX, 0)),
|
||||
}
|
||||
}
|
||||
};
|
||||
if shot != self.shot {
|
||||
self.shot = shot;
|
||||
self.view = self.view.wrapping_add(1).max(VIEW);
|
||||
self.held = None;
|
||||
self.fade = self.fade.max(3);
|
||||
}
|
||||
self.eye = eye;
|
||||
self.look = look;
|
||||
self.fov = fov;
|
||||
}
|
||||
|
||||
/// The camera the game renders for the replay.
|
||||
pub fn views(&self, (gw, gh): (f32, f32)) -> Vec<CameraView> {
|
||||
if matches!(self.mode, Mode::Map) {
|
||||
return Vec::new();
|
||||
}
|
||||
let d = (self.look - self.eye).normalize_or(DVec3::NEG_Z);
|
||||
let yaw = (-d.x).atan2(d.z).to_degrees() as f32;
|
||||
let pitch = (-d.y).asin().to_degrees() as f32;
|
||||
let width = 1280u32;
|
||||
let height = ((width as f32) * gh / gw.max(1.0)) as u32;
|
||||
vec![CameraView { id: self.view, x: self.eye.x, y: self.eye.y, z: self.eye.z, yaw, pitch, fov: self.fov, width, height: height.clamp(240, 1080) }]
|
||||
}
|
||||
|
||||
/// The replay's screen: the film with its titles, or the map.
|
||||
pub fn hud(&self, sim: &Sim, (gw, gh): (f32, f32)) -> Vec<Shape> {
|
||||
let Some(rec) = sim.replays.get(self.rec) else { return Vec::new() };
|
||||
if matches!(self.mode, Mode::Map) {
|
||||
return self.map(rec, gw, gh);
|
||||
}
|
||||
let mut s = vec![fill(0.0, 0.0, gw, gh, 0xFF000000)];
|
||||
s.push(Shape::View(ViewShape { view: self.view, rect: Rect { x: 0.0, y: 0.0, w: gw, h: gh }, mode: 0 }));
|
||||
// Letterbox, the recording's marks.
|
||||
let bar = (gh * 0.09).round();
|
||||
s.push(fill(0.0, 0.0, gw, bar, 0xFF000000));
|
||||
s.push(fill(0.0, gh - bar, gw, bar, 0xFF000000));
|
||||
let blink = (sim.tick / 10) % 2 == 0;
|
||||
s.push(fill(8.0, bar / 2.0 - 3.0, 6.0, 6.0, if blink { 0xFFFF2020 } else { 0x60FF2020 }));
|
||||
let what = match &self.mode {
|
||||
Mode::Full => "ПОЛНЫЙ ПОВТОР".to_string(),
|
||||
Mode::Clips { reel: true, at, list } => format!("ЛУЧШЕЕ · {}/{}", at + 1, list.len()),
|
||||
_ => "ПОВТОР".to_string(),
|
||||
};
|
||||
let head = format!("{what} · налёт №{}", rec.number);
|
||||
let head_w = horizon_mod_sdk::render::text_width(&head);
|
||||
s.push(text(head, 18.0, bar / 2.0 - 4.0, 0xFFFFFFFF, false));
|
||||
let speed = if let Mode::Clips { list, at, .. } = &self.mode {
|
||||
let te = rec.events[list[*at].event].at as f64;
|
||||
if (te - 14.0..te + 18.0).contains(&self.t) { 0.3 } else { 1.0 }
|
||||
} else {
|
||||
self.speed
|
||||
};
|
||||
let time = format!("{} / {} ×{}", clock(self.t), clock(rec.len as f64), speed);
|
||||
let tw = horizon_mod_sdk::render::text_width(&time);
|
||||
s.push(text(time, gw - 8.0 - tw, bar / 2.0 - 4.0, 0xFFC0C0C0, false));
|
||||
// The controls between them, where they fit.
|
||||
let hint = "колесо: ".to_string() + match self.mode { Mode::Full => "скорость", _ => "дальше / назад" } + " · R: выход";
|
||||
let hw = horizon_mod_sdk::render::text_width(&hint);
|
||||
let (left, right) = (18.0 + head_w + 12.0, gw - 8.0 - tw - 12.0);
|
||||
if right - left >= hw {
|
||||
s.push(text(hint, left + (right - left - hw) / 2.0, bar / 2.0 - 4.0, 0x80FFFFFF, false));
|
||||
}
|
||||
// Caption: what is happening.
|
||||
let caption = match &self.mode {
|
||||
Mode::Clips { list, at, .. } => Some(list[*at].event),
|
||||
_ => (self.shot.0 != usize::MAX).then_some(self.shot.0),
|
||||
};
|
||||
if let Some(i) = caption.filter(|&i| i < rec.events.len()) {
|
||||
let e = &rec.events[i];
|
||||
s.push(text(title(rec, i), gw / 2.0, gh - bar + 4.0, 0xFFFFFFFF, true));
|
||||
let detail = match e.kind {
|
||||
EventKind::Kill { sam, .. } => rec
|
||||
.sam(sam)
|
||||
.map(|(_, p)| format!("высота {:.0} м · {} от комплекса", e.pos.y - p.y, distance(e.pos.distance(p))))
|
||||
.unwrap_or_default(),
|
||||
EventKind::Hit { power, .. } => format!("сила взрыва {}", ["хлопок", "средний", "сильный", "тяжёлый", "мощнейший"][(power as usize).min(4)]),
|
||||
_ => String::new(),
|
||||
};
|
||||
s.push(text(detail, gw / 2.0, gh - bar + 15.0, 0xFFB0B0B0, true));
|
||||
}
|
||||
// Title card of a reel's moment.
|
||||
if self.card > 0 && let Mode::Clips { list, at, .. } = &self.mode {
|
||||
let a = ((self.card.min(15) as f32 / 15.0) * 255.0) as u32;
|
||||
s.push(fill(0.0, gh / 2.0 - 22.0, gw, 44.0, (a.min(0xC0) << 24) | 0x000000));
|
||||
s.push(text(format!("МОМЕНТ {} — {}", at + 1, clock(rec.events[list[*at].event].at as f64)), gw / 2.0, gh / 2.0 - 14.0, (a << 24) | 0xFFD040, true));
|
||||
s.push(text(title(rec, list[*at].event), gw / 2.0, gh / 2.0 + 2.0, (a << 24) | 0xFFFFFF, true));
|
||||
}
|
||||
if self.fade > 0 {
|
||||
let a = (self.fade.min(6) * 42) as u32;
|
||||
s.push(fill(0.0, 0.0, gw, gh, a << 24));
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// The raid from above: systems and their reach, objects, every track up to now, the events
|
||||
/// so far, and a time line.
|
||||
fn map(&self, rec: &Recording, gw: f32, gh: f32) -> Vec<Shape> {
|
||||
let mut s = vec![fill(0.0, 0.0, gw, gh, 0xF0060A08)];
|
||||
let o = rec.origin;
|
||||
// The area: everything that flew, but not far beyond the systems.
|
||||
let mut lo = (f64::MAX, f64::MAX);
|
||||
let mut hi = (f64::MIN, f64::MIN);
|
||||
let mut grow = |p: DVec3| {
|
||||
lo = (lo.0.min(p.x), lo.1.min(p.z));
|
||||
hi = (hi.0.max(p.x), hi.1.max(p.z));
|
||||
};
|
||||
for tr in &rec.tracks {
|
||||
if let What::Drone(k) = tr.what
|
||||
&& k.spec().ballistic.is_some()
|
||||
{
|
||||
continue;
|
||||
}
|
||||
for p in tr.path(o, 20, rec.len as f64) {
|
||||
grow(p);
|
||||
}
|
||||
}
|
||||
for sam in &rec.sams {
|
||||
grow(sam.2 - DVec3::splat(60.0));
|
||||
grow(sam.2 + DVec3::splat(60.0));
|
||||
}
|
||||
for p in &rec.objects {
|
||||
grow(*p);
|
||||
}
|
||||
if lo.0 > hi.0 {
|
||||
lo = (o.x - 200.0, o.z - 200.0);
|
||||
hi = (o.x + 200.0, o.z + 200.0);
|
||||
}
|
||||
let (top, bottom) = (20.0f32, 34.0f32);
|
||||
let (aw, ah) = (gw - 16.0, gh - top - bottom);
|
||||
let k = (aw as f64 / (hi.0 - lo.0).max(1.0)).min(ah as f64 / (hi.1 - lo.1).max(1.0));
|
||||
let cx = 8.0 + (aw as f64 - (hi.0 - lo.0) * k) / 2.0;
|
||||
let cy = top as f64 + (ah as f64 - (hi.1 - lo.1) * k) / 2.0;
|
||||
let at = |p: DVec3| ((cx + (p.x - lo.0) * k) as f32, (cy + (p.z - lo.1) * k) as f32);
|
||||
let inside = |(x, y): (f32, f32)| x > 0.0 && y > top - 4.0 && x < gw && y < gh - bottom + 4.0;
|
||||
// Systems' reach (a few), positions.
|
||||
let many = rec.sams.len() > 12;
|
||||
for (_, kind, p) in &rec.sams {
|
||||
let (x, y) = at(*p);
|
||||
if !many {
|
||||
let r = (kind.range() * k) as f32;
|
||||
let seg = 24;
|
||||
for i in 0..seg {
|
||||
let a0 = i as f32 / seg as f32 * std::f32::consts::TAU;
|
||||
let a1 = (i + 1) as f32 / seg as f32 * std::f32::consts::TAU;
|
||||
let q = |a: f32| (x + a.sin() * r, y - a.cos() * r);
|
||||
if inside(q(a0)) && inside(q(a1)) {
|
||||
s.push(line(q(a0), q(a1), 1.0, 0x5040A0FF));
|
||||
}
|
||||
}
|
||||
}
|
||||
s.push(fill(x - 2.0, y - 2.0, 4.0, 4.0, 0xFF40A0FF));
|
||||
}
|
||||
for p in &rec.objects {
|
||||
let (x, y) = at(*p);
|
||||
s.push(fill(x - 3.0, y - 3.0, 6.0, 6.0, 0xFFFFFFFF));
|
||||
}
|
||||
// Tracks up to now: a budget of segments shared out.
|
||||
let n = rec.tracks.len().max(1);
|
||||
let per = (640 / n).clamp(2, 14);
|
||||
for tr in &rec.tracks {
|
||||
let (color, head) = match tr.what {
|
||||
What::Drone(kind) if kind.spec().decoy => (0x70A0A0A0, 0xFFC0C0C0),
|
||||
What::Drone(_) => (0x90FF4040, 0xFFFF6060),
|
||||
What::Missile(..) => (0x90FFD040, 0xFFFFE070),
|
||||
};
|
||||
let pts = tr.path(o, 1, self.t);
|
||||
if pts.len() < 2 {
|
||||
continue;
|
||||
}
|
||||
let every = pts.len().div_ceil(per).max(1);
|
||||
let mut prev = at(pts[0]);
|
||||
for (i, p) in pts.iter().enumerate().skip(1) {
|
||||
if i % every != 0 && i != pts.len() - 1 {
|
||||
continue;
|
||||
}
|
||||
let q = at(*p);
|
||||
if inside(prev) && inside(q) {
|
||||
s.push(line(prev, q, 1.0, color));
|
||||
}
|
||||
prev = q;
|
||||
}
|
||||
// Its head while it flies.
|
||||
if (self.t as u32) < tr.last() && tr.fell.is_none_or(|f| (f as f64) > self.t) && inside(prev) {
|
||||
s.push(fill(prev.0 - 1.5, prev.1 - 1.5, 3.0, 3.0, head));
|
||||
}
|
||||
}
|
||||
// Events so far.
|
||||
for e in rec.events.iter().filter(|e| (e.at as f64) <= self.t) {
|
||||
let (x, y) = at(e.pos);
|
||||
if !inside((x, y)) {
|
||||
continue;
|
||||
}
|
||||
match e.kind {
|
||||
EventKind::Kill { .. } => {
|
||||
s.push(line((x - 2.5, y - 2.5), (x + 2.5, y + 2.5), 1.2, 0xFFFFE040));
|
||||
s.push(line((x + 2.5, y - 2.5), (x - 2.5, y + 2.5), 1.2, 0xFFFFE040));
|
||||
}
|
||||
EventKind::Hit { power, .. } => {
|
||||
let r = 2.0 + power as f32;
|
||||
s.push(fill(x - r, y - r, r * 2.0, r * 2.0, 0xB0FF3020));
|
||||
}
|
||||
EventKind::SamLost { .. } => s.push(fill(x - 4.0, y - 4.0, 8.0, 8.0, 0xFF200000)),
|
||||
EventKind::Split { .. } => s.push(fill(x - 2.0, y - 2.0, 4.0, 4.0, 0xFFFF9020)),
|
||||
}
|
||||
}
|
||||
// Header, legend, time line.
|
||||
let kills = rec.events.iter().filter(|e| (e.at as f64) <= self.t && matches!(e.kind, EventKind::Kill { .. })).count();
|
||||
let hits = rec.events.iter().filter(|e| (e.at as f64) <= self.t && matches!(e.kind, EventKind::Hit { .. })).count();
|
||||
s.push(text(format!("КАРТА НАЛЁТА №{} · {} · сбито {kills} · прилётов {hits}", rec.number, clock(self.t)), 8.0, 6.0, 0xFF9FE0FF, false));
|
||||
s.push(text("красный: цели · серый: ложные · жёлтый: перехватчики · x сбит · ■ прилёт · колесо: время · R выход", 8.0, gh - 12.0, 0x90FFFFFF, false));
|
||||
let (tx, ty, tw) = (8.0, gh - bottom + 6.0, gw - 16.0);
|
||||
s.push(fill(tx, ty, tw, 3.0, 0x60FFFFFF));
|
||||
let len = rec.len.max(1) as f32;
|
||||
for e in &rec.events {
|
||||
let x = tx + tw * e.at as f32 / len;
|
||||
let c = match e.kind {
|
||||
EventKind::Kill { .. } => 0xFFFFE040,
|
||||
EventKind::Hit { .. } => 0xFFFF3020,
|
||||
EventKind::SamLost { .. } => 0xFFFF00FF,
|
||||
EventKind::Split { .. } => 0xFFFF9020,
|
||||
};
|
||||
s.push(fill(x, ty - 2.0, 1.0, 7.0, c));
|
||||
}
|
||||
s.push(fill(tx + tw * (self.t as f32 / len) - 1.0, ty - 4.0, 2.0, 11.0, 0xFFFFFFFF));
|
||||
s.truncate(1024);
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
impl Player {
|
||||
pub fn event_clip(rec: &Recording, i: usize) -> Mode {
|
||||
Mode::Clips { list: vec![clip(rec, i)], at: 0, reel: false }
|
||||
}
|
||||
}
|
||||
@@ -81,6 +81,7 @@ impl Sim {
|
||||
sam.bursts = 0;
|
||||
let pos = sam.pos + DVec3::Y;
|
||||
out.messages.push(format!("{} №{} УНИЧТОЖЕН", sam.kind.name(), i + 1));
|
||||
let (id, kind) = (sam.id, sam.kind);
|
||||
let charge = spec.missile.as_ref().map_or(0.0, |m| m.kind.charge() * missiles as f64) + bursts as f64 / 60.0;
|
||||
// The vehicle's own fuel and the first of its load at once, then the rest cooking off.
|
||||
let first = (1.0 + charge * 0.6).round().clamp(1.0, 8.0) as u32;
|
||||
@@ -91,6 +92,7 @@ impl Sim {
|
||||
let tnt = if charge > 4.0 && self.rng.chance(0.4) { 2 } else { 1 };
|
||||
self.later.push((when, at, tnt, true));
|
||||
}
|
||||
self.log(pos, record::EventKind::SamLost { sam: id, kind, index: i });
|
||||
// Shells pop in strings.
|
||||
for k in 0..(bursts / 12).min(14) {
|
||||
let when = now + 10 + (k as u64) * 6 + (self.rng.f() * 8.0) as u64;
|
||||
|
||||
@@ -11,6 +11,7 @@ use std::collections::HashMap;
|
||||
|
||||
mod damage;
|
||||
mod raid;
|
||||
pub mod record;
|
||||
mod sight;
|
||||
pub use raid::{Approach, Aim, RaidOrder};
|
||||
|
||||
@@ -686,6 +687,15 @@ struct MissileSpec {
|
||||
}
|
||||
|
||||
impl MissileKind {
|
||||
/// The sound of its launch.
|
||||
pub fn launch_sound(self) -> &'static str {
|
||||
match self {
|
||||
MissileKind::Pac3 => "airdef:launch.patriot",
|
||||
MissileKind::M57e6 => "airdef:launch.pantsir",
|
||||
MissileKind::M48n6 => "airdef:launch.s400_eject",
|
||||
MissileKind::M77n6 => "airdef:launch.s500_eject",
|
||||
}
|
||||
}
|
||||
fn spec(self) -> &'static MissileSpec {
|
||||
match self {
|
||||
MissileKind::Pac3 => &MissileSpec {
|
||||
@@ -1112,6 +1122,10 @@ pub struct Sim {
|
||||
pub target_health: Vec<f64>,
|
||||
/// The raid in progress, for its report.
|
||||
wave: Option<raid::WaveStats>,
|
||||
/// The raid being recorded, the last ones recorded, and how many have been.
|
||||
rec: Option<record::Recording>,
|
||||
pub replays: Vec<record::Recording>,
|
||||
recordings: u32,
|
||||
}
|
||||
|
||||
/// Ids: objects get multiples of 16, their parts the low bits.
|
||||
@@ -1141,6 +1155,9 @@ impl Sim {
|
||||
queue: Vec::new(),
|
||||
target_health: Vec::new(),
|
||||
wave: None,
|
||||
rec: None,
|
||||
replays: Vec::new(),
|
||||
recordings: 0,
|
||||
}
|
||||
}
|
||||
pub fn id(&mut self) -> u32 {
|
||||
@@ -1240,6 +1257,7 @@ impl Sim {
|
||||
self.draw_targets(out);
|
||||
self.step_wrecks(out);
|
||||
self.report_wave(out);
|
||||
self.record();
|
||||
let now = self.tick;
|
||||
self.blasts.retain(|b| now - b.start < b.life as u64);
|
||||
}
|
||||
@@ -1252,6 +1270,9 @@ impl Sim {
|
||||
let mut removed: Vec<u32> = Vec::new();
|
||||
// Oreshnik pieces released this tick: kind, at, velocity, target.
|
||||
let mut released: Vec<(DroneKind, DVec3, DVec3, DVec3)> = Vec::new();
|
||||
// Warheads that reached their aim (for the replays): drone, kind, where, TNT; and splits.
|
||||
let mut impacts: Vec<(u32, DroneKind, DVec3, u32)> = Vec::new();
|
||||
let mut splits: Vec<(u32, DVec3)> = Vec::new();
|
||||
for d in &mut self.drones {
|
||||
d.age += 1;
|
||||
let spec = d.kind.spec();
|
||||
@@ -1295,6 +1316,7 @@ impl Sim {
|
||||
|| d.age > 4000;
|
||||
if hit {
|
||||
boom.push((d.pos, spec.warhead, false));
|
||||
impacts.push((d.id, d.kind, d.pos, spec.warhead));
|
||||
removed.push(d.id);
|
||||
self.hits += 1;
|
||||
continue;
|
||||
@@ -1318,6 +1340,7 @@ impl Sim {
|
||||
released.push((piece, d.pos + v.normalize_or_zero() * (i as f64 * 0.3), v, aim));
|
||||
}
|
||||
out.sound("airdef:boom.sonic", d.pos, 1.0, 0.7);
|
||||
splits.push((d.id, d.pos));
|
||||
// Its pieces count as launched instead of it.
|
||||
self.launched += 5;
|
||||
out.particles("minecraft:firework", d.pos, 1.5, DVec3::ZERO, 0.3, 40);
|
||||
@@ -1393,6 +1416,9 @@ impl Sim {
|
||||
let in_ground = below.is_some_and(|g| d.pos.y <= g + 0.2);
|
||||
if at_target || in_ground || d.age > 8000 {
|
||||
boom.push((d.pos, spec.warhead, spec.decoy));
|
||||
if !spec.decoy {
|
||||
impacts.push((d.id, d.kind, d.pos, spec.warhead));
|
||||
}
|
||||
removed.push(d.id);
|
||||
if !spec.decoy {
|
||||
self.hits += 1;
|
||||
@@ -1417,6 +1443,21 @@ impl Sim {
|
||||
out.sound(event, d.pos, 1.0, pitch);
|
||||
}
|
||||
}
|
||||
for (drone, pos) in splits {
|
||||
self.log(pos, record::EventKind::Split { drone });
|
||||
}
|
||||
for (drone, kind, pos, tnt) in impacts {
|
||||
let power = match tnt {
|
||||
0 => 0,
|
||||
1 | 2 => 1,
|
||||
3..=5 => 2,
|
||||
6 | 7 => 3,
|
||||
_ => 4,
|
||||
};
|
||||
let object = self.targets.iter().position(|t| t.distance(pos) < 16.0);
|
||||
let sam = self.sams.iter().enumerate().find(|(_, s)| s.alive() && s.pos.distance(pos) < 12.0).map(|(i, s)| (s.kind, i));
|
||||
self.log(pos, record::EventKind::Hit { drone, kind, power, object, sam });
|
||||
}
|
||||
for (pos, warhead, small) in boom {
|
||||
self.explode(pos, warhead, small, ground, player, out);
|
||||
}
|
||||
@@ -1546,11 +1587,16 @@ impl Sim {
|
||||
}
|
||||
|
||||
/// A drone hit by air defence: a flash, pieces, and it falls burning.
|
||||
fn shoot_down(&mut self, idx: usize, by: u32, out: &mut Out) {
|
||||
let d = &mut self.drones[idx];
|
||||
if !d.alive() {
|
||||
fn shoot_down(&mut self, idx: usize, by: u32, missile: Option<u32>, out: &mut Out) {
|
||||
if !self.drones[idx].alive() {
|
||||
return;
|
||||
}
|
||||
if let Some((i, s)) = self.sams.iter().enumerate().find(|(_, s)| s.id == by) {
|
||||
let (drone, kind, pos) = (self.drones[idx].id, self.drones[idx].kind, self.drones[idx].pos);
|
||||
let kill = record::EventKind::Kill { drone, kind, sam: by, sam_kind: s.kind, sam_index: i, missile };
|
||||
self.log(pos, kill);
|
||||
}
|
||||
let d = &mut self.drones[idx];
|
||||
d.flight = Flight::Falling;
|
||||
d.age = 0;
|
||||
d.vel = d.vel * 0.6 + DVec3::new(0.0, 0.15, 0.0);
|
||||
@@ -1798,7 +1844,7 @@ impl Sim {
|
||||
}
|
||||
for (t, by) in gun_hits {
|
||||
if let Some(i) = self.drones.iter().position(|d| d.id == t) {
|
||||
self.shoot_down(i, by, out);
|
||||
self.shoot_down(i, by, None, out);
|
||||
}
|
||||
}
|
||||
for i in 0..self.sams.len() {
|
||||
@@ -1950,7 +1996,7 @@ impl Sim {
|
||||
if let Some(t) = target.and_then(|t| self.drones.iter().position(|d| d.id == t)) {
|
||||
self.drones[t].engaged = self.drones[t].engaged.saturating_sub(1);
|
||||
if kill {
|
||||
self.shoot_down(t, sam, out);
|
||||
self.shoot_down(t, sam, Some(mid), out);
|
||||
}
|
||||
}
|
||||
// A missile that lost its target frees it for others.
|
||||
|
||||
@@ -0,0 +1,269 @@
|
||||
//! Raids are recorded for their replays: every drone's and interceptor's
|
||||
//! track (a point every other tick, falling wrecks included) and what
|
||||
//! happened (shot down, by what; hits; systems lost; the Oreshnik's split).
|
||||
//! A recording starts with the first drone in the sky and ends when the sky
|
||||
//! has been clear a while; the last few are kept.
|
||||
use super::*;
|
||||
|
||||
/// Ticks between a track's points.
|
||||
pub const STEP: u32 = 2;
|
||||
/// The longest recording (10 minutes) and how many are kept.
|
||||
const LONGEST: u32 = 12_000;
|
||||
const KEPT: usize = 3;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Debug)]
|
||||
pub enum What {
|
||||
Drone(DroneKind),
|
||||
/// An interceptor and the system that fired it.
|
||||
Missile(MissileKind, u32),
|
||||
}
|
||||
|
||||
pub struct Track {
|
||||
pub id: u32,
|
||||
pub what: What,
|
||||
/// The recording's tick of its first point.
|
||||
pub first: u32,
|
||||
/// Its points, `STEP` ticks apart, relative to the recording's origin.
|
||||
points: Vec<[f32; 3]>,
|
||||
/// When it was shot down (a drone falling from then on).
|
||||
pub fell: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Debug)]
|
||||
pub enum EventKind {
|
||||
/// A drone shot down: by which system (its index then), with a missile or the guns.
|
||||
Kill { drone: u32, kind: DroneKind, sam: u32, sam_kind: SamKind, sam_index: usize, missile: Option<u32> },
|
||||
/// A drone's warhead went off where it aimed: at an object, a system, or the land.
|
||||
Hit { drone: u32, kind: DroneKind, power: u32, object: Option<usize>, sam: Option<(SamKind, usize)> },
|
||||
/// A system destroyed.
|
||||
SamLost { sam: u32, kind: SamKind, index: usize },
|
||||
/// The Oreshnik's bus or a block splitting.
|
||||
Split { drone: u32 },
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Event {
|
||||
pub at: u32,
|
||||
pub pos: DVec3,
|
||||
pub kind: EventKind,
|
||||
}
|
||||
|
||||
pub struct Recording {
|
||||
/// Which raid of the session (1, 2, …).
|
||||
pub number: u32,
|
||||
pub origin: DVec3,
|
||||
/// Its length in ticks.
|
||||
pub len: u32,
|
||||
pub tracks: Vec<Track>,
|
||||
index: HashMap<u32, usize>,
|
||||
pub events: Vec<Event>,
|
||||
/// The systems and objects as they stood: (id, kind, where).
|
||||
pub sams: Vec<(u32, SamKind, DVec3)>,
|
||||
pub objects: Vec<DVec3>,
|
||||
/// Ticks the sky has been clear.
|
||||
quiet: u32,
|
||||
}
|
||||
|
||||
impl Track {
|
||||
/// Where it was at `t` (the recording's ticks, fractional), if it was.
|
||||
pub fn at(&self, origin: DVec3, t: f64) -> Option<DVec3> {
|
||||
let k = (t - self.first as f64) / STEP as f64;
|
||||
if k < 0.0 || self.points.is_empty() || k > (self.points.len() - 1) as f64 {
|
||||
return None;
|
||||
}
|
||||
let i = (k.floor() as usize).min(self.points.len() - 1);
|
||||
let j = (i + 1).min(self.points.len() - 1);
|
||||
let f = k - i as f64;
|
||||
let p = |q: [f32; 3]| DVec3::new(q[0] as f64, q[1] as f64, q[2] as f64);
|
||||
Some(origin + p(self.points[i]).lerp(p(self.points[j]), f))
|
||||
}
|
||||
/// Which way it was flying at `t`.
|
||||
pub fn dir(&self, origin: DVec3, t: f64) -> DVec3 {
|
||||
let a = self.at(origin, t - STEP as f64).or_else(|| self.at(origin, t));
|
||||
let b = self.at(origin, t + STEP as f64).or_else(|| self.at(origin, t));
|
||||
match (a, b) {
|
||||
(Some(a), Some(b)) => (b - a).normalize_or(DVec3::NEG_Z),
|
||||
_ => DVec3::NEG_Z,
|
||||
}
|
||||
}
|
||||
/// The tick of its last point.
|
||||
pub fn last(&self) -> u32 {
|
||||
self.first + (self.points.len().max(1) as u32 - 1) * STEP
|
||||
}
|
||||
/// Its points, every `every`-th, up to tick `t`.
|
||||
pub fn path(&self, origin: DVec3, every: usize, t: f64) -> Vec<DVec3> {
|
||||
let p = |q: &[f32; 3]| origin + DVec3::new(q[0] as f64, q[1] as f64, q[2] as f64);
|
||||
let upto = ((t - self.first as f64) / STEP as f64).floor();
|
||||
if upto < 0.0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let upto = (upto as usize).min(self.points.len().saturating_sub(1));
|
||||
let mut out: Vec<DVec3> = self.points[..=upto].iter().step_by(every.max(1)).map(p).collect();
|
||||
if upto % every.max(1) != 0 {
|
||||
out.push(p(&self.points[upto]));
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
impl Recording {
|
||||
fn new(number: u32, sim: &Sim) -> Self {
|
||||
let origin = sim.targets.first().copied().or_else(|| sim.sams.first().map(|s| s.pos)).unwrap_or(DVec3::ZERO);
|
||||
Recording {
|
||||
number,
|
||||
origin: origin.floor(),
|
||||
len: 0,
|
||||
tracks: Vec::new(),
|
||||
index: HashMap::new(),
|
||||
events: Vec::new(),
|
||||
sams: sim.sams.iter().map(|s| (s.id, s.kind, s.pos)).collect(),
|
||||
objects: sim.targets.clone(),
|
||||
quiet: 0,
|
||||
}
|
||||
}
|
||||
fn point(&mut self, id: u32, what: What, pos: DVec3) {
|
||||
let rel = pos - self.origin;
|
||||
let q = [rel.x as f32, rel.y as f32, rel.z as f32];
|
||||
let now = self.len;
|
||||
match self.index.get(&id) {
|
||||
Some(&i) => self.tracks[i].points.push(q),
|
||||
None => {
|
||||
self.index.insert(id, self.tracks.len());
|
||||
self.tracks.push(Track { id, what, first: now, points: vec![q], fell: None });
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn track(&self, id: u32) -> Option<&Track> {
|
||||
self.index.get(&id).map(|&i| &self.tracks[i])
|
||||
}
|
||||
/// The system with this id as it stood.
|
||||
pub fn sam(&self, id: u32) -> Option<(SamKind, DVec3)> {
|
||||
self.sams.iter().find(|s| s.0 == id).map(|s| (s.1, s.2))
|
||||
}
|
||||
}
|
||||
|
||||
impl Sim {
|
||||
/// Something worth a replay happened.
|
||||
pub(super) fn log(&mut self, pos: DVec3, kind: EventKind) {
|
||||
if let Some(r) = &mut self.rec {
|
||||
let at = r.len;
|
||||
if let EventKind::Kill { drone, .. } = kind
|
||||
&& let Some(&i) = r.index.get(&drone)
|
||||
{
|
||||
r.tracks[i].fell = Some(at);
|
||||
}
|
||||
r.events.push(Event { at, pos, kind });
|
||||
}
|
||||
}
|
||||
|
||||
/// Once a tick: starts a recording with the first drone, adds the tracks' points, ends it
|
||||
/// when the sky has been clear 5 s.
|
||||
pub(super) fn record(&mut self) {
|
||||
// Wrecks still falling (far off they fall a long while) don't keep it going.
|
||||
let busy = self.drones.iter().any(|d| d.alive()) || !self.missiles.is_empty() || !self.queue.is_empty();
|
||||
if self.rec.is_none() {
|
||||
// It starts with the first drone in the sky (not with a raid's drones still waiting).
|
||||
if !self.drones.iter().any(|d| d.alive()) {
|
||||
return;
|
||||
}
|
||||
self.recordings += 1;
|
||||
self.rec = Some(Recording::new(self.recordings, self));
|
||||
}
|
||||
let Some(r) = &mut self.rec else { return };
|
||||
if r.len % STEP == 0 {
|
||||
for d in &self.drones {
|
||||
r.point(d.id, What::Drone(d.kind), d.pos);
|
||||
}
|
||||
for m in &self.missiles {
|
||||
r.point(m.id, What::Missile(m.kind, m.sam), m.pos);
|
||||
}
|
||||
}
|
||||
r.len += 1;
|
||||
r.quiet = if busy { 0 } else { r.quiet + 1 };
|
||||
if r.quiet >= 100 || r.len >= LONGEST {
|
||||
let mut done = self.rec.take().unwrap();
|
||||
done.len = done.len.saturating_sub(done.quiet.saturating_sub(40));
|
||||
if !done.events.is_empty() {
|
||||
self.replays.push(done);
|
||||
if self.replays.len() > KEPT {
|
||||
self.replays.remove(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Draws the recording's drones and interceptors as they were at `t`, as ghosts: ids from `base`.
|
||||
pub fn draw_ghosts(&self, rec: &Recording, t: f64, base: u32, out: &mut Out) {
|
||||
for (k, tr) in rec.tracks.iter().enumerate() {
|
||||
let Some(pos) = tr.at(rec.origin, t) else { continue };
|
||||
let dir = tr.dir(rec.origin, t);
|
||||
let id = base + k as u32 * PARTS;
|
||||
match tr.what {
|
||||
What::Drone(kind) => {
|
||||
let spec = kind.spec();
|
||||
let s = spec.scale;
|
||||
let falling = tr.fell.is_some_and(|f| t >= f as f64);
|
||||
let mut rot = look(dir, 0.0);
|
||||
if falling {
|
||||
let spin = (t - tr.fell.unwrap_or(0) as f64) * 0.35;
|
||||
rot = rot * DQuat::from_rotation_z(spin) * DQuat::from_rotation_x(-0.6);
|
||||
out.model(id, spec.model, pos, rot, s, false);
|
||||
out.model(id + 1, "airdef:flame", pos, rot, 0.6 + 0.2 * ((t * 1.7).sin() + 1.0), true);
|
||||
continue;
|
||||
}
|
||||
if !matches!(kind, DroneKind::OreshnikBlock | DroneKind::OreshnikSub) {
|
||||
out.model(id, spec.model, pos, rot, s, false);
|
||||
}
|
||||
match spec.engine {
|
||||
Engine::Prop(back, size) => {
|
||||
let at = pos + rot * DVec3::new(0.0, 0.0, back * s);
|
||||
out.model(id + 1, "airdef:shahed_prop", at, rot * DQuat::from_rotation_z(t * 1.1), s * size, false);
|
||||
}
|
||||
Engine::Jet(up, back, size) => {
|
||||
out.model(id + 1, "airdef:geran3_flame", pos + rot * DVec3::new(0.0, up * s, back * s), rot, s * size, true);
|
||||
}
|
||||
Engine::Rocket(back, size) => {
|
||||
if matches!(kind, DroneKind::OreshnikBlock | DroneKind::OreshnikSub) {
|
||||
out.model(id + 1, "airdef:reentry", pos, rot, s, true);
|
||||
} else if spec.ballistic.is_none() || t - (tr.first as f64) < 60.0 {
|
||||
out.model(id + 1, "airdef:flame", pos + rot * DVec3::new(0.0, 0.0, back * s + size), rot, size, true);
|
||||
} else {
|
||||
out.model(id + 1, "airdef:reentry", pos, rot, s * 0.6, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
What::Missile(kind, _) => {
|
||||
let spec = kind.spec();
|
||||
let rot = look(dir, 0.0) * DQuat::from_rotation_z(t * 0.3);
|
||||
out.model(id, spec.model, pos, rot, spec.scale, false);
|
||||
if t - tr.first as f64 > spec.cold as f64 {
|
||||
let back = (spec.rear - 8.0) / 16.0 * spec.scale + spec.flame;
|
||||
out.model(id + 1, "airdef:flame", pos + rot * DVec3::new(0.0, 0.0, back), rot, spec.flame, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Blasts: a fireball growing and fading for 1.5 s after each.
|
||||
for (k, e) in rec.events.iter().enumerate() {
|
||||
let age = t - e.at as f64;
|
||||
if !(0.0..30.0).contains(&age) {
|
||||
continue;
|
||||
}
|
||||
let size = match e.kind {
|
||||
EventKind::Kill { .. } => 3.5,
|
||||
EventKind::Hit { power, .. } => [2.5, 4.5, 7.0, 10.0, 13.0][(power as usize).min(4)],
|
||||
EventKind::SamLost { .. } => 8.0,
|
||||
EventKind::Split { .. } => 2.0,
|
||||
};
|
||||
let f = age / 30.0;
|
||||
let s = size * (f * 4.0).min(1.0) * (1.0 - f * f);
|
||||
let id = base + 0x0080_0000 + k as u32 * PARTS;
|
||||
let spin = DQuat::from_rotation_y(age * 0.05);
|
||||
out.model(id, "airdef:fireball", e.pos + DVec3::Y * age * 0.04, spin, s.max(0.01), true);
|
||||
if age < 4.0 {
|
||||
out.model(id + 1, "airdef:flash", e.pos, spin, size * 0.6, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
From 3de7a6875140a107e28563cc44489b55f5794517 Mon Sep 17 00:00:00 2001
|
||||
From: chexit <chexit@duck.com>
|
||||
Date: Wed, 28 Oct 2026 12:37:45 +0300
|
||||
Subject: [PATCH 1/6] Mod API (AirDef fork): world models, client particles,
|
||||
Subject: [PATCH 1/7] Mod API (AirDef fork): world models, client particles,
|
||||
sounds, ground heights
|
||||
|
||||
render.set-models draws block models with an interpolated pose per id;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
From a6d64e6415bf618539af464e521091e72b72d72f Mon Sep 17 00:00:00 2001
|
||||
From: chexit <chexit@duck.com>
|
||||
Date: Wed, 28 Oct 2026 12:39:45 +0300
|
||||
Subject: [PATCH 2/6] cargo-horizon-mod: report particles and sounds
|
||||
Subject: [PATCH 2/7] cargo-horizon-mod: report particles and sounds
|
||||
|
||||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
||||
---
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
From ee79b3562feebe51959a01f1585a9e85bd53ccb5 Mon Sep 17 00:00:00 2001
|
||||
From: chexit <chexit@duck.com>
|
||||
Date: Wed, 28 Oct 2026 13:33:10 +0300
|
||||
Subject: [PATCH 3/6] Mod API (AirDef fork): full-screen post pass for mods
|
||||
Subject: [PATCH 3/7] Mod API (AirDef fork): full-screen post pass for mods
|
||||
|
||||
render.set-post compiles a mod's WGSL after a prelude (camera matrices,
|
||||
time, 256 vec4 of params, the world's colour and depth) and runs it after
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
From 2b137dbbedd540daeebc7f5e387847aeb56a1355 Mon Sep 17 00:00:00 2001
|
||||
From: chexit <chexit@duck.com>
|
||||
Date: Wed, 28 Oct 2026 22:09:30 +0300
|
||||
Subject: [PATCH 4/6] Mod models: draw far models as scaled impostors past the
|
||||
Subject: [PATCH 4/7] Mod models: draw far models as scaled impostors past the
|
||||
far plane, cull at 4096
|
||||
|
||||
---
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
From c8ebca6e0af68630e65211844b34d25c5b985c03 Mon Sep 17 00:00:00 2001
|
||||
From: chexit <chexit@duck.com>
|
||||
Date: Wed, 28 Oct 2026 22:31:00 +0300
|
||||
Subject: [PATCH 5/6] Mod cameras: render.set-views draws the world from other
|
||||
Subject: [PATCH 5/7] Mod cameras: render.set-views draws the world from other
|
||||
points into pictures that HUD view shapes show (API level 9)
|
||||
|
||||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
From 8d2261fc4f8072c32e454139cfea7a8c0cd9d664 Mon Sep 17 00:00:00 2001
|
||||
From: chexit <chexit@duck.com>
|
||||
Date: Wed, 28 Oct 2026 23:08:21 +0300
|
||||
Subject: [PATCH 6/6] Mods: more fuel per tick and per event (AirDef plans
|
||||
Subject: [PATCH 6/7] Mods: more fuel per tick and per event (AirDef plans
|
||||
raids)
|
||||
|
||||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
From 6c548de34def8e4a624d734243418090798bd16a Mon Sep 17 00:00:00 2001
|
||||
From: chexit <chexit@duck.com>
|
||||
Date: Wed, 28 Oct 2026 23:25:29 +0300
|
||||
Subject: [PATCH 7/7] Mod cameras up to 1920x1080 (full-screen replays)
|
||||
|
||||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
||||
---
|
||||
crates/horizon-mod-sdk/wit/horizon.wit | 2 +-
|
||||
crates/horizon-mods/src/runtime.rs | 4 ++--
|
||||
2 files changed, 3 insertions(+), 3 deletions(-)
|
||||
|
||||
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
|
||||
index 436455a19..e30f3a30e 100644
|
||||
--- a/crates/horizon-mod-sdk/wit/horizon.wit
|
||||
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
|
||||
@@ -523,7 +523,7 @@ interface render {
|
||||
pitch: f32,
|
||||
/// Vertical field of view, degrees (1 to 110).
|
||||
fov: f32,
|
||||
- /// The picture's size in pixels (16 to 640 × 16 to 480).
|
||||
+ /// The picture's size in pixels (16 to 1920 × 16 to 1080).
|
||||
width: u32,
|
||||
height: u32,
|
||||
}
|
||||
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
|
||||
index a551b7376..1389407be 100644
|
||||
--- a/crates/horizon-mods/src/runtime.rs
|
||||
+++ b/crates/horizon-mods/src/runtime.rs
|
||||
@@ -1991,8 +1991,8 @@ impl render::Host for State {
|
||||
v.yaw = angle(v.yaw);
|
||||
v.pitch = angle(v.pitch).clamp(-90.0, 90.0);
|
||||
v.fov = if v.fov.is_finite() { v.fov.clamp(1.0, 110.0) } else { 70.0 };
|
||||
- v.width = v.width.clamp(16, 640);
|
||||
- v.height = v.height.clamp(16, 480);
|
||||
+ v.width = v.width.clamp(16, 1920);
|
||||
+ v.height = v.height.clamp(16, 1080);
|
||||
v
|
||||
})
|
||||
.collect();
|
||||
--
|
||||
2.54.0 (Apple Git-157)
|
||||
|
||||
Reference in New Issue
Block a user