use std::collections::HashMap;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct AnimFrame {
pub start: u32,
pub end: u32,
pub speed: f32,
}
impl AnimFrame {
#[must_use]
pub fn from_inf(s: &str) -> Option<Self> {
let parts: Vec<&str> = s.split(',').collect();
if parts.len() != 3 {
return None;
}
Some(Self {
start: parts[0].trim().parse().ok()?,
end: parts[1].trim().parse().ok()?,
speed: parts[2].trim().parse().ok()?,
})
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnitAnimations {
pub idle1: Option<AnimFrame>,
pub idle2: Option<AnimFrame>,
pub idle3: Option<AnimFrame>,
pub move_: Option<AnimFrame>,
pub attack: Option<AnimFrame>,
pub use_: Option<AnimFrame>,
pub die: Option<AnimFrame>,
pub special: Option<AnimFrame>,
}
impl Default for UnitAnimations {
fn default() -> Self {
Self {
idle1: None,
idle2: None,
idle3: None,
move_: None,
attack: None,
use_: None,
die: None,
special: None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct LootEntry {
pub item_id: u32,
pub max_count: u32,
}
impl LootEntry {
#[must_use]
pub fn from_inf(s: &str) -> Self {
let parts: Vec<&str> = s.split(',').collect();
let item_id = parts.first().and_then(|p| p.trim().parse().ok()).unwrap_or(0);
let max_count = parts
.get(1)
.and_then(|p| p.trim().parse().ok())
.unwrap_or(1);
let max_count = if max_count <= 1 { 1 } else { max_count };
Self { item_id, max_count }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct VehicleParams {
pub acceleration: f32,
pub friction: f32,
pub steering: u32,
pub max_depth: u32,
pub fly_speed: f32,
}
impl Default for VehicleParams {
fn default() -> Self {
Self {
acceleration: 0.03,
friction: 0.04,
steering: 2,
max_depth: 3,
fly_speed: 3.0,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnitDef {
pub id: u32,
pub name: String,
#[serde(default)]
pub group: String,
#[serde(default)]
pub icon: Option<String>,
#[serde(default)]
pub model: Option<String>,
#[serde(default = "default_scale")]
pub scale: f32,
#[serde(default)]
pub fx: Option<u32>,
#[serde(default)]
pub color: Option<[u8; 3]>,
#[serde(default = "default_alpha")]
pub alpha: f32,
#[serde(default)]
pub shininess: Option<f32>,
#[serde(default = "default_autofade")]
pub auto_fade: u32,
#[serde(default = "default_col")]
pub collision_mode: u32,
#[serde(default = "default_col_radius")]
pub collision_x_radius: f32,
#[serde(default = "default_col_radius")]
pub collision_y_radius: f32,
#[serde(default = "default_mat")]
pub material: String,
#[serde(default = "default_unit_health")]
pub health: f32,
#[serde(default)]
pub health_change: Option<f32>,
#[serde(default = "default_damage")]
pub damage: f32,
#[serde(default = "default_speed")]
pub speed: f32,
#[serde(default = "default_turn_speed")]
pub turn_speed: f32,
#[serde(default)]
pub eye_height: f32,
#[serde(default = "default_store")]
pub store: f32,
#[serde(default = "default_max_weight")]
pub max_weight: u32,
#[serde(default)]
pub behaviour: Option<String>,
#[serde(default = "default_range")]
pub perception_range: u32,
#[serde(default = "default_attack_range")]
pub attack_range: u32,
#[serde(default)]
pub territory: u32,
#[serde(default)]
pub search_ratio: f32,
#[serde(default)]
pub loot: Vec<LootEntry>,
#[serde(default)]
pub sfx: Option<String>,
#[serde(default)]
pub state: UnitState,
#[serde(default)]
pub align: u32,
#[serde(default = "default_ride_offset")]
pub ride_offset: f32,
#[serde(default)]
pub vehicle: Option<VehicleParams>,
#[serde(default)]
pub animations: UnitAnimations,
#[serde(default)]
pub loop_move_anim: bool,
#[serde(default)]
pub script: Option<String>,
#[serde(default)]
pub description: Option<String>,
#[serde(default = "default_true")]
pub in_editor: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum UnitState {
Random,
Fixed(f32, f32, f32),
}
impl Default for UnitState {
fn default() -> Self {
Self::Random
}
}
const fn default_scale() -> f32 {
1.0
}
const fn default_alpha() -> f32 {
1.0
}
const fn default_autofade() -> u32 {
500
}
const fn default_col() -> u32 {
1
}
const fn default_col_radius() -> f32 {
1.0
}
fn default_mat() -> String {
"flesh".to_owned()
}
const fn default_unit_health() -> f32 {
5.0
}
const fn default_damage() -> f32 {
1.0
}
const fn default_speed() -> f32 {
2.0
}
const fn default_turn_speed() -> f32 {
2.0
}
const fn default_store() -> f32 {
100.0
}
const fn default_max_weight() -> u32 {
100000
}
const fn default_range() -> u32 {
300
}
const fn default_attack_range() -> u32 {
50
}
const fn default_ride_offset() -> f32 {
30.0
}
const fn default_true() -> bool {
true
}
fn first_str<'a>(fields: &'a HashMap<String, Vec<String>>, key: &str) -> Option<&'a str> {
fields.get(key)?.first().map(String::as_str)
}
fn first_string(fields: &HashMap<String, Vec<String>>, key: &str) -> Option<String> {
first_str(fields, key).map(ToOwned::to_owned)
}
fn first_u32(fields: &HashMap<String, Vec<String>>, key: &str) -> Option<u32> {
first_str(fields, key)?.parse().ok()
}
fn first_f32(fields: &HashMap<String, Vec<String>>, key: &str) -> Option<f32> {
first_str(fields, key)?.parse().ok()
}
fn parse_color(s: &str) -> Option<[u8; 3]> {
let parts: Vec<&str> = s.split(',').collect();
if parts.len() != 3 {
return None;
}
Some([
parts[0].trim().parse().ok()?,
parts[1].trim().parse().ok()?,
parts[2].trim().parse().ok()?,
])
}
fn parse_loot(fields: &HashMap<String, Vec<String>>) -> Vec<LootEntry> {
fields
.get("loot")
.map(|vals| vals.iter().map(|v| LootEntry::from_inf(v)).collect())
.unwrap_or_default()
}
impl UnitDef {
#[must_use]
pub fn from_inf_fields(fields: &HashMap<String, Vec<String>>) -> Option<Self> {
let id = first_u32(fields, "id")?;
let name = first_string(fields, "name")?;
let group = first_string(fields, "group").unwrap_or_default();
let icon = first_string(fields, "icon");
let model = first_string(fields, "model");
let behaviour = first_string(fields, "behaviour");
let scale = first_f32(fields, "scale").unwrap_or(1.0);
let fx = first_u32(fields, "fx");
let color = first_str(fields, "color").and_then(parse_color).or_else(|| {
let r = first_u32(fields, "r")? as u8;
let g = first_u32(fields, "g")? as u8;
let b = first_u32(fields, "b")? as u8;
Some([r, g, b])
});
let alpha = first_f32(fields, "alpha").unwrap_or(1.0);
let shininess = first_f32(fields, "shine");
let auto_fade = first_u32(fields, "autofade").unwrap_or(500);
let collision_mode = first_u32(fields, "col").unwrap_or(1);
let collision_x_radius = first_f32(fields, "colxr").unwrap_or(1.0);
let collision_y_radius = first_f32(fields, "colyr").unwrap_or(1.0);
let material = first_string(fields, "mat").unwrap_or_else(|| "flesh".to_owned());
let health = first_f32(fields, "health").unwrap_or(5.0);
let health_change = first_f32(fields, "healthchange");
let damage = first_f32(fields, "damage").unwrap_or(1.0);
let speed = first_f32(fields, "speed").unwrap_or(2.0);
let turn_speed = first_f32(fields, "turnspeed").unwrap_or(2.0);
let eye_height = first_f32(fields, "eyes").unwrap_or(0.0);
let store = first_f32(fields, "store").unwrap_or(100.0);
let max_weight = first_u32(fields, "maxweight").unwrap_or(100000);
let perception_range = first_u32(fields, "range").unwrap_or(300);
let attack_range = first_u32(fields, "attackrange").unwrap_or(50);
let territory = first_u32(fields, "territory").unwrap_or(0);
let search_ratio = first_f32(fields, "searchratio").unwrap_or(0.0);
let loot = parse_loot(fields);
let sfx = first_string(fields, "sfx");
let state = match first_str(fields, "state") {
Some("random") | None => UnitState::Random,
Some(s) => {
let parts: Vec<&str> = s.split(',').collect();
if parts.len() == 3 {
if let (Ok(a), Ok(b), Ok(c)) = (
parts[0].trim().parse(),
parts[1].trim().parse(),
parts[2].trim().parse(),
) {
UnitState::Fixed(a, b, c)
} else {
UnitState::Random
}
} else {
UnitState::Random
}
}
};
let align = first_u32(fields, "align").unwrap_or(0);
let ride_offset = first_f32(fields, "rideoffset").unwrap_or(30.0);
let has_any_vehicle_field = first_f32(fields, "acceleration").is_some()
|| first_f32(fields, "friction").is_some()
|| first_u32(fields, "steering").is_some()
|| first_u32(fields, "maxdepth").is_some()
|| first_f32(fields, "flyspeed").is_some();
let vehicle = if has_any_vehicle_field {
Some(VehicleParams {
acceleration: first_f32(fields, "acceleration").unwrap_or(0.03),
friction: first_f32(fields, "friction").unwrap_or(0.04),
steering: first_u32(fields, "steering").unwrap_or(2),
max_depth: first_u32(fields, "maxdepth").unwrap_or(3),
fly_speed: first_f32(fields, "flyspeed").unwrap_or(3.0),
})
} else {
None
};
let animations = UnitAnimations {
idle1: first_str(fields, "ani_idle1").and_then(AnimFrame::from_inf),
idle2: first_str(fields, "ani_idle2").and_then(AnimFrame::from_inf),
idle3: first_str(fields, "ani_idle3").and_then(AnimFrame::from_inf),
move_: first_str(fields, "ani_move").and_then(AnimFrame::from_inf),
attack: first_str(fields, "ani_attack").and_then(AnimFrame::from_inf),
use_: first_str(fields, "ani_use").and_then(AnimFrame::from_inf),
die: first_str(fields, "ani_die").and_then(AnimFrame::from_inf),
special: first_str(fields, "ani_special").and_then(AnimFrame::from_inf),
};
let loop_move_anim = first_u32(fields, "loopmoveani").unwrap_or(0) != 0;
let in_editor = first_u32(fields, "editor").map_or(true, |v| v != 0);
let script = None;
let description = None;
Some(Self {
id,
name,
group,
icon,
model,
scale,
fx,
color,
alpha,
shininess,
auto_fade,
collision_mode,
collision_x_radius,
collision_y_radius,
material,
health,
health_change,
damage,
speed,
turn_speed,
eye_height,
store,
max_weight,
behaviour,
perception_range,
attack_range,
territory,
search_ratio,
loot,
sfx,
state,
align,
ride_offset,
vehicle,
animations,
loop_move_anim,
script,
description,
in_editor,
})
}
#[must_use]
pub fn with_script(mut self, script: Option<String>) -> Self {
self.script = script;
self
}
#[must_use]
pub fn with_description(mut self, description: Option<String>) -> Self {
self.description = description;
self
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_anim_frame_from_inf() {
let frame = AnimFrame::from_inf("2,3,0.06").unwrap();
assert_eq!(frame.start, 2);
assert_eq!(frame.end, 3);
assert!((frame.speed - 0.06).abs() < 1e-6);
}
#[test]
fn test_anim_frame_invalid() {
assert!(AnimFrame::from_inf("2,3").is_none());
assert!(AnimFrame::from_inf("").is_none());
}
#[test]
fn test_loot_entry_from_inf() {
let loot = LootEntry::from_inf("9,3");
assert_eq!(loot.item_id, 9);
assert_eq!(loot.max_count, 3);
}
#[test]
fn test_loot_entry_minimal() {
let loot = LootEntry::from_inf("11");
assert_eq!(loot.item_id, 11);
assert_eq!(loot.max_count, 1);
}
#[test]
fn test_loot_entry_clamp() {
let loot = LootEntry::from_inf("5,0");
assert_eq!(loot.item_id, 5);
assert_eq!(loot.max_count, 1);
}
#[test]
fn test_unit_from_inf_minimal() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["1".into()]);
fields.insert("name".into(), vec!["Player".into()]);
let unit = UnitDef::from_inf_fields(&fields).unwrap();
assert_eq!(unit.id, 1);
assert_eq!(unit.name, "Player");
assert_eq!(unit.group, "");
assert!((unit.health - 5.0).abs() < 1e-6);
assert_eq!(unit.material, "flesh");
assert!(unit.in_editor);
}
#[test]
fn test_unit_from_inf_full() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["2".into()]);
fields.insert("name".into(), vec!["Raptor".into()]);
fields.insert("group".into(), vec!["animal".into()]);
fields.insert("icon".into(), vec!["gfx/raptor.png".into()]);
fields.insert("model".into(), vec!["gfx/raptor.glb".into()]);
fields.insert("behaviour".into(), vec!["raptor".into()]);
fields.insert("col".into(), vec!["1".into()]);
fields.insert("colxr".into(), vec!["15".into()]);
fields.insert("colyr".into(), vec!["30".into()]);
fields.insert("health".into(), vec!["110".into()]);
fields.insert("mat".into(), vec!["flesh".into()]);
fields.insert("damage".into(), vec!["24".into()]);
fields.insert("speed".into(), vec!["2.5".into()]);
fields.insert("turnspeed".into(), vec!["3.0".into()]);
fields.insert("eyes".into(), vec!["10".into()]);
fields.insert("store".into(), vec!["100".into()]);
fields.insert("maxweight".into(), vec!["25000".into()]);
fields.insert("range".into(), vec!["300".into()]);
fields.insert("attackrange".into(), vec!["65".into()]);
fields.insert("loot".into(), vec!["9,3".into(), "94,8".into()]);
fields.insert("sfx".into(), vec!["raptor".into()]);
fields.insert("scale".into(), vec!["0.5".into()]);
fields.insert("fx".into(), vec!["16".into()]);
fields.insert("ani_move".into(), vec!["2,3,0.06".into()]);
fields.insert("ani_attack".into(), vec!["12,16,0.07".into()]);
fields.insert("ani_idle1".into(), vec!["4,8,0.02".into()]);
fields.insert("ani_die".into(), vec!["8,11,0.05".into()]);
let unit = UnitDef::from_inf_fields(&fields).unwrap();
assert_eq!(unit.id, 2);
assert_eq!(unit.name, "Raptor");
assert_eq!(unit.group, "animal");
assert_eq!(unit.behaviour.as_deref(), Some("raptor"));
assert!((unit.health - 110.0).abs() < 1e-6);
assert!((unit.damage - 24.0).abs() < 1e-6);
assert!((unit.speed - 2.5).abs() < 1e-6);
assert!((unit.turn_speed - 3.0).abs() < 1e-6);
assert!((unit.eye_height - 10.0).abs() < 1e-6);
assert!((unit.scale - 0.5).abs() < 1e-6);
assert_eq!(unit.loot.len(), 2);
assert_eq!(unit.loot[0].item_id, 9);
assert_eq!(unit.loot[0].max_count, 3);
assert_eq!(unit.sfx.as_deref(), Some("raptor"));
let anim = unit.animations.move_.unwrap();
assert_eq!(anim.start, 2);
assert_eq!(anim.end, 3);
}
#[test]
fn test_unit_missing_id() {
let fields = HashMap::new();
assert!(UnitDef::from_inf_fields(&fields).is_none());
}
#[test]
fn test_unit_with_vehicle_params() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["10".into()]);
fields.insert("name".into(), vec!["Boat".into()]);
fields.insert("acceleration".into(), vec!["0.05".into()]);
fields.insert("friction".into(), vec!["0.02".into()]);
fields.insert("steering".into(), vec!["3".into()]);
fields.insert("maxdepth".into(), vec!["10".into()]);
fields.insert("flyspeed".into(), vec!["0".into()]);
fields.insert("rideoffset".into(), vec!["5".into()]);
let unit = UnitDef::from_inf_fields(&fields).unwrap();
let v = unit.vehicle.unwrap();
assert!((v.acceleration - 0.05).abs() < 1e-6);
assert!((v.friction - 0.02).abs() < 1e-6);
assert_eq!(v.steering, 3);
assert_eq!(v.max_depth, 10);
assert!((unit.ride_offset - 5.0).abs() < 1e-6);
}
#[test]
fn test_unit_with_regular_fields_no_vehicle() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["3".into()]);
fields.insert("name".into(), vec!["Crab".into()]);
fields.insert("health".into(), vec!["40".into()]);
let unit = UnitDef::from_inf_fields(&fields).unwrap();
assert!(unit.vehicle.is_none());
}
#[test]
fn test_unit_with_script_and_description() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["1".into()]);
fields.insert("name".into(), vec!["Player".into()]);
let unit = UnitDef::from_inf_fields(&fields)
.unwrap()
.with_script(Some("on:start { msg \"Hello\"; }".into()))
.with_description(Some("The player character".into()));
assert_eq!(
unit.script.as_deref(),
Some("on:start { msg \"Hello\"; }")
);
assert_eq!(unit.description.as_deref(), Some("The player character"));
}
#[test]
fn test_state_serde_derives_compile() {
let unit = UnitDef {
id: 1,
name: "test".into(),
group: String::new(),
icon: None,
model: None,
scale: 1.0,
fx: None,
color: None,
alpha: 1.0,
shininess: None,
auto_fade: 500,
collision_mode: 1,
collision_x_radius: 1.0,
collision_y_radius: 1.0,
material: "flesh".into(),
health: 5.0,
health_change: None,
damage: 1.0,
speed: 2.0,
turn_speed: 2.0,
eye_height: 0.0,
store: 100.0,
max_weight: 100000,
behaviour: None,
perception_range: 300,
attack_range: 50,
territory: 0,
search_ratio: 0.0,
loot: vec![],
sfx: None,
state: UnitState::Random,
align: 0,
ride_offset: 30.0,
vehicle: None,
animations: UnitAnimations::default(),
loop_move_anim: false,
script: None,
description: None,
in_editor: true,
};
assert_eq!(unit.id, 1);
}
}