Files
airdef/airdef-mod/src/wave.rs
T
chexit 4d7815834d
build / mod (push) Failing after 28s
Give each battery variant its own placeable remote
Every catalog variant now has a `airdef:deploy_<id>` remote in `give` and
in the hotbar: deploy_radar_search, deploy_radar_track, deploy_radar_height,
deploy_s400_launcher and deploy_s500_launcher. The variant rows carry their
remote item in the generated catalog, and the inventory appends them after
the existing remotes so no ordinary remote changes slot.

Placing a remote now resolves the item back to its (kind, mode, role)
configuration and settles the system, the same path `/airdef deploy <key>`
already used. The base remotes keep deploying the ordinary integrated,
multifunction system; the radar remotes place Search/Engagement/Height
profiles, so radar_track gets fire authority and the others do not.

The N menu's battery-deploy page is removed entirely (button, page and its
handlers); variants remain available through `/airdef deploy` and now the
remotes. Items, icons (aliased to the unit silhouettes), lang entries and
generated assets are regenerated from the content catalog.

Checks: gen_catalog.py --check, gen_models.py --check, test_gen_assets (11),
airdef-mod lib 115 + integration suites, airdef-core 327, cargo build.
2026-11-21 16:44:23 +03:00

248 lines
10 KiB
Rust

//! The raid the player orders from the menu: how many of each kind, from
//! where, how far out and at what; and ready-made raids to start from.
use crate::sim::{Aim, Approach, DroneKind, RaidOrder};
/// The historical raid order is owned by the shared content catalog.
pub use crate::sim::catalog::RAID_KINDS as KINDS;
/// What a click on a kind's row steps its number through.
const STEPS: [u32; 12] = [0, 1, 2, 3, 4, 6, 8, 10, 15, 20, 30, 40];
pub const DISTANCES: [f64; 7] = [200.0, 300.0, 500.0, 800.0, 1500.0, 2500.0, 4000.0];
/// The nearest and farthest start a raid may be ordered at (blocks).
pub const DIST_MIN: f64 = 60.0;
pub const DIST_MAX: f64 = 4000.0;
pub struct Preset {
pub name: &'static str,
kinds: &'static [(DroneKind, u32)],
approach: Approach,
aim: Aim,
}
pub const PRESETS: [Preset; 7] = [
Preset {
name: "Рой Шахедов",
kinds: &[(DroneKind::Gerbera, 10), (DroneKind::Shahed, 20), (DroneKind::Geran3, 4)],
approach: Approach::TwoSectors,
aim: Aim::Objects,
},
Preset {
name: "Массированный удар",
kinds: &[
(DroneKind::Gerbera, 8),
(DroneKind::Shahed, 12),
(DroneKind::Geran3, 4),
(DroneKind::Kh101, 4),
(DroneKind::Kalibr, 4),
(DroneKind::Kh22, 2),
(DroneKind::Iskander, 2),
],
approach: Approach::AllSides,
aim: Aim::Smart,
},
Preset {
name: "Баллистика",
kinds: &[(DroneKind::Gerbera, 4), (DroneKind::Iskander, 4), (DroneKind::Kinzhal, 2)],
approach: Approach::Sector,
aim: Aim::ObjectsAndSams,
},
Preset {
name: "Гиперзвук",
kinds: &[(DroneKind::Kh22, 3), (DroneKind::Zircon, 4), (DroneKind::Kinzhal, 3)],
approach: Approach::TwoSectors,
aim: Aim::Smart,
},
Preset {
name: "Орешник с прикрытием",
kinds: &[(DroneKind::Gerbera, 6), (DroneKind::Shahed, 10), (DroneKind::Iskander, 2), (DroneKind::Oreshnik, 1)],
approach: Approach::Sector,
aim: Aim::Smart,
},
Preset {
name: "Подавление ПВО",
kinds: &[(DroneKind::Gerbera, 8), (DroneKind::Lancet, 8), (DroneKind::Shahed, 8), (DroneKind::Kh22, 4)],
approach: Approach::AllSides,
aim: Aim::Smart,
},
Preset { name: "Пусто", kinds: &[], approach: Approach::Sector, aim: Aim::Objects },
];
pub struct WaveConfig {
pub counts: [u32; KINDS.len()],
pub approach: Approach,
pub dist: f64,
pub aim: Aim,
/// The last preset applied.
pub preset: usize,
}
impl Default for WaveConfig {
fn default() -> Self {
let mut w = WaveConfig { counts: [0; KINDS.len()], approach: Approach::Sector, dist: 300.0, aim: Aim::Smart, preset: 1 };
w.apply(1);
w
}
}
impl WaveConfig {
pub fn apply(&mut self, preset: usize) {
let p = &PRESETS[preset % PRESETS.len()];
self.preset = preset % PRESETS.len();
self.counts = [0; KINDS.len()];
for &(kind, n) in p.kinds {
if let Some(i) = KINDS.iter().position(|k| *k == kind) {
self.counts[i] = n;
}
}
self.approach = p.approach;
self.aim = p.aim;
}
/// The words of a scenario's `wave` line: counts, approach, distance, aim, preset.
pub fn text(&self) -> String {
let counts: Vec<String> = self.counts.iter().map(u32::to_string).collect();
let approach = Approach::ALL.iter().position(|a| *a == self.approach).unwrap_or(0);
let aim = Aim::ALL.iter().position(|a| *a == self.aim).unwrap_or(0);
format!("{} {approach} {} {aim} {}", counts.join(","), self.dist, self.preset)
}
/// Whether `w` are words `parse` would read whole: an error says which is wrong (#86).
pub fn check(&self, w: &[&str]) -> Result<(), String> {
if let Some(c) = w.first() {
if c.split(',').take(KINDS.len()).any(|v| v.parse::<u32>().is_err()) {
return Err(format!("число по типам: «{c}»"));
}
}
if w.get(1).is_some_and(|v| v.parse::<usize>().ok().is_none_or(|i| i >= Approach::ALL.len())) {
return Err(format!("подход: «{}»", w[1]));
}
if w.get(2).is_some_and(|v| v.parse::<f64>().ok().is_none_or(|d| !d.is_finite())) {
return Err(format!("дальность: «{}»", w[2]));
}
if w.get(3).is_some_and(|v| v.parse::<usize>().ok().is_none_or(|i| i >= Aim::ALL.len())) {
return Err(format!("цель налёта: «{}»", w[3]));
}
if w.get(4).is_some_and(|v| v.parse::<usize>().is_err()) {
return Err(format!("набор: «{}»", w[4]));
}
Ok(())
}
/// Reads `text`'s words; what does not parse keeps its value.
pub fn parse(&mut self, w: &[&str]) {
if let Some(c) = w.first() {
for (i, v) in c.split(',').take(KINDS.len()).enumerate() {
if let Ok(n) = v.parse::<u32>() {
self.counts[i] = n.min(80);
}
}
}
if let Some(a) = w.get(1).and_then(|v| v.parse::<usize>().ok()).and_then(|i| Approach::ALL.get(i)) {
self.approach = *a;
}
if let Some(d) = w.get(2).and_then(|v| v.parse::<f64>().ok()) {
self.dist = d.clamp(DIST_MIN, DIST_MAX);
}
if let Some(a) = w.get(3).and_then(|v| v.parse::<usize>().ok()).and_then(|i| Aim::ALL.get(i)) {
self.aim = *a;
}
if let Some(p) = w.get(4).and_then(|v| v.parse::<usize>().ok()) {
self.preset = p % PRESETS.len();
}
}
/// The next number for kind `i`, back to 0 after the last.
pub fn step(&mut self, i: usize) {
let n = self.counts[i];
self.counts[i] = STEPS.iter().copied().find(|&s| s > n).unwrap_or(0);
}
pub fn total(&self) -> u32 {
self.counts.iter().sum()
}
pub fn order(&self) -> RaidOrder {
RaidOrder {
kinds: KINDS.iter().copied().zip(self.counts).filter(|k| k.1 > 0).collect(),
approach: self.approach,
dist: self.dist,
aim: self.aim,
}
}
/// A combined strike of about `n`, as `/airdef wave mix n` orders it.
pub fn mix(n: u32, dist: f64) -> RaidOrder {
RaidOrder::mix(n, dist)
}
}
#[cfg(test)]
mod catalog_tests {
use super::*;
use crate::sim::catalog::{AIRCRAFT, UNITS, VARIANTS};
fn assets() -> std::path::PathBuf {
std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("assets/airdef")
}
fn item_exists(item: &str) {
let name = item.strip_prefix("airdef:").expect("item namespace");
for path in [format!("items/{name}.json"), format!("models/item/{name}.json")] {
assert!(assets().join(&path).is_file(), "{item}: missing {path}");
}
let definition = std::fs::read_to_string(assets().join(format!("items/{name}.json"))).unwrap();
assert!(definition.contains(&format!("airdef:item/{name}")), "{item}: wrong item model");
let model = std::fs::read_to_string(assets().join(format!("models/item/{name}.json"))).unwrap();
// The icon reference may be an alias of an existing texture (the optical post uses the
// radar icon until its own asset lands, #136); what matters is that the PNG it names exists.
let layer = model
.split("\"layer0\": \"")
.nth(1)
.and_then(|s| s.split('"').next())
.unwrap_or_else(|| panic!("{item}: no icon reference"));
let texture = layer.strip_prefix("airdef:item/").unwrap_or_else(|| panic!("{item}: bad icon reference {layer}"));
let png = std::fs::read(assets().join(format!("textures/item/{texture}.png"))).unwrap();
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"), "{item}: invalid PNG signature");
}
fn model_exists(model: &str) {
let name = model.strip_prefix("airdef:").expect("model namespace");
let path = assets().join(format!("models/block/{name}.json"));
assert!(path.is_file(), "missing model {}", path.display());
}
#[test]
fn catalog_resources_exist() {
for aircraft in AIRCRAFT {
model_exists(aircraft.kind.spec().model());
if let Some(item) = aircraft.launch_item { item_exists(item); }
}
for unit in UNITS {
item_exists(unit.deploy_item);
let p = &unit.kind.spec().parts;
model_exists(p.body);
for model in [p.launcher, p.pack, p.dish.map(|v| v.0), p.spinner.map(|v| v.0)].into_iter().flatten() { model_exists(model); }
for (model, _, _) in p.fixed { model_exists(model); }
}
for variant in VARIANTS {
item_exists(variant.deploy_item);
}
}
#[test]
fn inventory_entries_match_catalog_and_scenario_order_round_trips() {
let catalogued = |item: &str| {
AIRCRAFT.iter().any(|a| a.launch_item == Some(item))
|| UNITS.iter().any(|u| u.deploy_item == item)
|| VARIANTS.iter().any(|v| v.deploy_item == item)
};
for item in AIRCRAFT.iter().filter_map(|a| a.launch_item)
.chain(UNITS.iter().map(|u| u.deploy_item))
.chain(VARIANTS.iter().map(|v| v.deploy_item))
{
assert_eq!(crate::ITEMS.iter().filter(|i| **i == item).count(), 1, "{item}");
}
for item in crate::ITEMS.iter().filter(|i| i.starts_with("airdef:launch_") || i.starts_with("airdef:deploy_")) {
assert!(catalogued(item), "uncatalogued item {item}");
}
let mut wave = WaveConfig::default();
for (i, count) in wave.counts.iter_mut().enumerate() { *count = i as u32; }
let text = wave.text();
let mut restored = WaveConfig::default();
restored.parse(&text.split_whitespace().collect::<Vec<_>>());
assert_eq!(restored.counts, wave.counts);
assert_eq!(restored.order().kinds, KINDS.iter().copied().zip(wave.counts).filter(|(_, n)| *n > 0).collect::<Vec<_>>());
}
}