use std::collections::HashMap;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CollisionMode {
None = 0,
Normal = 1,
Climbable = 2,
Wall = 3,
}
impl CollisionMode {
#[must_use]
pub fn from_inf(n: u32) -> Self {
match n {
0 => Self::None,
2 => Self::Climbable,
3 => Self::Wall,
_ => Self::Normal,
}
}
}
impl Default for CollisionMode {
fn default() -> Self {
Self::Normal
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct ObjectScale {
pub x: f32,
pub y: f32,
pub z: f32,
}
impl ObjectScale {
#[must_use]
pub const fn uniform(v: f32) -> Self {
Self { x: v, y: v, z: v }
}
}
impl Default for ObjectScale {
fn default() -> Self {
Self::uniform(1.0)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ObjectState {
Random,
Fixed(f32, f32, f32),
}
impl Default for ObjectState {
fn default() -> Self {
Self::Random
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct SpawnDef {
pub item_id: u32,
pub rate_days: u32,
pub xz_radius: f32,
pub y_radius: f32,
pub y_offset: f32,
pub limit: u32,
pub count: u32,
}
impl SpawnDef {
#[must_use]
pub fn from_inf(s: &str) -> Option<Self> {
let parts: Vec<&str> = s.split(',').collect();
if parts.len() != 7 {
return None;
}
Some(Self {
item_id: parts[0].trim().parse().ok()?,
rate_days: parts[1].trim().parse().ok()?,
xz_radius: parts[2].trim().parse().ok()?,
y_radius: parts[3].trim().parse().ok()?,
y_offset: parts[4].trim().parse().ok()?,
limit: parts[5].trim().parse().ok()?,
count: parts[6].trim().parse().ok()?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct HarvestDef {
pub item_id: u32,
pub ratio: u32,
pub max: u32,
pub min: u32,
pub required_item: u32,
}
impl HarvestDef {
#[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 ratio = parts.get(1).and_then(|p| p.trim().parse().ok()).unwrap_or(1);
let max = parts.get(2).and_then(|p| p.trim().parse().ok()).unwrap_or(1);
let min = parts.get(3).and_then(|p| p.trim().parse().ok()).unwrap_or(1);
let required_item = parts.get(4).and_then(|p| p.trim().parse().ok()).unwrap_or(0);
let ratio = if ratio <= 0 { 1 } else { ratio };
let max = if max <= 1 { 1 } else { max };
let min = if min <= 1 { 1 } else { min };
let min = if min >= max { max } else { min };
Self {
item_id,
ratio,
max,
min,
required_item,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ObjectDef {
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)]
pub behaviour: Option<String>,
#[serde(default)]
pub scale: ObjectScale,
#[serde(default)]
pub color: Option<[u8; 3]>,
#[serde(default)]
pub fx: Option<u32>,
#[serde(default = "default_alpha")]
pub alpha: f32,
#[serde(default)]
pub shininess: Option<f32>,
#[serde(default = "default_autofade")]
pub auto_fade: u32,
#[serde(default)]
pub detail_tex: Option<String>,
#[serde(default)]
pub collision_mode: CollisionMode,
#[serde(default)]
pub material: String,
#[serde(default = "default_health")]
pub health: f32,
#[serde(default)]
pub health_change: Option<f32>,
#[serde(default)]
pub sway_speed: Option<f32>,
#[serde(default = "default_sway_power")]
pub sway_power: f32,
#[serde(default = "default_max_weight")]
pub max_weight: u32,
#[serde(default)]
pub state: ObjectState,
#[serde(default)]
pub align: u32,
#[serde(default = "default_search_ratio")]
pub search_ratio: f32,
#[serde(default = "default_grow_time")]
pub grow_time: u32,
#[serde(default)]
pub spawn: Option<SpawnDef>,
#[serde(default)]
pub harvest: Vec<HarvestDef>,
#[serde(default)]
pub script: Option<String>,
#[serde(default)]
pub description: Option<String>,
#[serde(default = "default_true")]
pub in_editor: bool,
}
const fn default_alpha() -> f32 {
1.0
}
const fn default_autofade() -> u32 {
500
}
const fn default_health() -> f32 {
500.0
}
const fn default_sway_power() -> f32 {
1.0
}
const fn default_max_weight() -> u32 {
100000
}
const fn default_search_ratio() -> f32 {
30.0
}
const fn default_grow_time() -> u32 {
10
}
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_harvest(fields: &HashMap<String, Vec<String>>) -> Vec<HarvestDef> {
fields
.get("find")
.map(|vals| vals.iter().map(|v| HarvestDef::from_inf(v)).collect())
.unwrap_or_default()
}
impl ObjectDef {
#[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 material = first_string(fields, "mat").unwrap_or_default();
let scale_uniform = first_f32(fields, "scale");
let scale_x = first_f32(fields, "x");
let scale_y = first_f32(fields, "y");
let scale_z = first_f32(fields, "z");
let scale = ObjectScale {
x: scale_x.or(scale_uniform).unwrap_or(1.0),
y: scale_y.or(scale_uniform).unwrap_or(1.0),
z: scale_z.or(scale_uniform).unwrap_or(1.0),
};
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 fx = first_u32(fields, "fx");
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 detail_tex = first_string(fields, "detailtex");
let collision_mode = first_u32(fields, "col")
.map(CollisionMode::from_inf)
.unwrap_or_default();
let health = first_f32(fields, "health").unwrap_or(500.0);
let health_change = first_f32(fields, "healthchange");
let sway_speed = first_f32(fields, "swayspeed");
let sway_power = first_f32(fields, "swaypower").unwrap_or(1.0);
let max_weight = first_u32(fields, "maxweight").unwrap_or(100000);
let state = match first_str(fields, "state") {
Some("random") | None => ObjectState::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(),
) {
ObjectState::Fixed(a, b, c)
} else {
ObjectState::Random
}
} else {
ObjectState::Random
}
}
};
let align = first_u32(fields, "align").unwrap_or(0);
let search_ratio = first_f32(fields, "searchratio")
.or_else(|| first_f32(fields, "findratio"))
.unwrap_or(30.0);
let grow_time = first_u32(fields, "growtime").unwrap_or(10);
let spawn = first_str(fields, "spawn").and_then(SpawnDef::from_inf);
let harvest = parse_harvest(fields);
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,
behaviour,
scale,
color,
fx,
alpha,
shininess,
auto_fade,
detail_tex,
collision_mode,
material,
health,
health_change,
sway_speed,
sway_power,
max_weight,
state,
align,
search_ratio,
grow_time,
spawn,
harvest,
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_collision_mode_from_inf() {
assert_eq!(CollisionMode::from_inf(0), CollisionMode::None);
assert_eq!(CollisionMode::from_inf(1), CollisionMode::Normal);
assert_eq!(CollisionMode::from_inf(2), CollisionMode::Climbable);
assert_eq!(CollisionMode::from_inf(3), CollisionMode::Wall);
assert_eq!(CollisionMode::from_inf(99), CollisionMode::Normal);
}
#[test]
fn test_object_scale_uniform() {
let s = ObjectScale::uniform(2.5);
assert!((s.x - 2.5).abs() < 1e-6);
assert!((s.y - 2.5).abs() < 1e-6);
assert!((s.z - 2.5).abs() < 1e-6);
}
#[test]
fn test_spawn_def_from_inf() {
let spawn = SpawnDef::from_inf("14,3,15,3,125,3,1").unwrap();
assert_eq!(spawn.item_id, 14);
assert_eq!(spawn.rate_days, 3);
assert!((spawn.xz_radius - 15.0).abs() < 1e-6);
assert!((spawn.y_radius - 3.0).abs() < 1e-6);
assert!((spawn.y_offset - 125.0).abs() < 1e-6);
assert_eq!(spawn.limit, 3);
assert_eq!(spawn.count, 1);
}
#[test]
fn test_spawn_def_invalid() {
assert!(SpawnDef::from_inf("14,3").is_none());
assert!(SpawnDef::from_inf("").is_none());
}
#[test]
fn test_harvest_def_minimal() {
let h = HarvestDef::from_inf("15,15,3");
assert_eq!(h.item_id, 15);
assert_eq!(h.ratio, 15);
assert_eq!(h.max, 3);
assert_eq!(h.min, 1);
assert_eq!(h.required_item, 0);
}
#[test]
fn test_harvest_def_full() {
let h = HarvestDef::from_inf("107,150,3,1,28");
assert_eq!(h.item_id, 107);
assert_eq!(h.ratio, 150);
assert_eq!(h.max, 3);
assert_eq!(h.min, 1);
assert_eq!(h.required_item, 28);
}
#[test]
fn test_object_from_inf_minimal() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["1".into()]);
fields.insert("name".into(), vec!["Palm".into()]);
let obj = ObjectDef::from_inf_fields(&fields).unwrap();
assert_eq!(obj.id, 1);
assert_eq!(obj.name, "Palm");
assert_eq!(obj.group, "");
assert_eq!(obj.collision_mode, CollisionMode::Normal);
assert!((obj.health - 500.0).abs() < 1e-6);
assert_eq!(obj.state, ObjectState::Random);
assert!(obj.in_editor);
}
#[test]
fn test_object_from_inf_full() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["8".into()]);
fields.insert("name".into(), vec!["Banana Palm".into()]);
fields.insert("group".into(), vec!["palm".into()]);
fields.insert("icon".into(), vec!["gfx/bananapalm.png".into()]);
fields.insert("model".into(), vec!["gfx/bananapalm.glb".into()]);
fields.insert("behaviour".into(), vec!["tree".into()]);
fields.insert("col".into(), vec!["1".into()]);
fields.insert("health".into(), vec!["300".into()]);
fields.insert("mat".into(), vec!["wood".into()]);
fields.insert("fx".into(), vec!["16".into()]);
fields.insert("scale".into(), vec!["2.5".into()]);
fields.insert("swayspeed".into(), vec!["1.5".into()]);
fields.insert("swaypower".into(), vec!["2".into()]);
fields.insert("spawn".into(), vec!["14,3,15,3,125,3,1".into()]);
fields.insert("find".into(), vec!["15,15,3".into()]);
let obj = ObjectDef::from_inf_fields(&fields).unwrap();
assert_eq!(obj.id, 8);
assert_eq!(obj.name, "Banana Palm");
assert_eq!(obj.group, "palm");
assert_eq!(obj.behaviour.as_deref(), Some("tree"));
assert!((obj.scale.x - 2.5).abs() < 1e-6);
assert!((obj.scale.y - 2.5).abs() < 1e-6);
assert!((obj.scale.z - 2.5).abs() < 1e-6);
assert!((obj.health - 300.0).abs() < 1e-6);
assert_eq!(obj.material, "wood");
assert_eq!(obj.fx, Some(16));
assert_eq!(obj.spawn.unwrap().item_id, 14);
assert_eq!(obj.harvest.len(), 1);
assert_eq!(obj.harvest[0].item_id, 15);
}
#[test]
fn test_object_missing_id() {
let fields = HashMap::new();
assert!(ObjectDef::from_inf_fields(&fields).is_none());
}
#[test]
fn test_object_with_color() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["5".into()]);
fields.insert("name".into(), vec!["Red Flower".into()]);
fields.insert("color".into(), vec!["255,0,0".into()]);
let obj = ObjectDef::from_inf_fields(&fields).unwrap();
assert_eq!(obj.color, Some([255, 0, 0]));
}
#[test]
fn test_object_with_individual_color() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["5".into()]);
fields.insert("name".into(), vec!["Colored".into()]);
fields.insert("r".into(), vec!["128".into()]);
fields.insert("g".into(), vec!["64".into()]);
fields.insert("b".into(), vec!["32".into()]);
let obj = ObjectDef::from_inf_fields(&fields).unwrap();
assert_eq!(obj.color, Some([128, 64, 32]));
}
#[test]
fn test_object_with_individual_scale() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["1".into()]);
fields.insert("name".into(), vec!["Stretched".into()]);
fields.insert("x".into(), vec!["2".into()]);
fields.insert("y".into(), vec!["3".into()]);
fields.insert("z".into(), vec!["4".into()]);
let obj = ObjectDef::from_inf_fields(&fields).unwrap();
assert!((obj.scale.x - 2.0).abs() < 1e-6);
assert!((obj.scale.y - 3.0).abs() < 1e-6);
assert!((obj.scale.z - 4.0).abs() < 1e-6);
}
#[test]
fn test_object_state_random() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["1".into()]);
fields.insert("name".into(), vec!["Random".into()]);
fields.insert("state".into(), vec!["random".into()]);
let obj = ObjectDef::from_inf_fields(&fields).unwrap();
assert_eq!(obj.state, ObjectState::Random);
}
#[test]
fn test_object_state_fixed() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["1".into()]);
fields.insert("name".into(), vec!["Fixed".into()]);
fields.insert("state".into(), vec!["10,20,30".into()]);
let obj = ObjectDef::from_inf_fields(&fields).unwrap();
assert_eq!(obj.state, ObjectState::Fixed(10.0, 20.0, 30.0));
}
#[test]
fn test_object_with_script_and_description() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["150".into()]);
fields.insert("name".into(), vec!["Building Site".into()]);
let obj = ObjectDef::from_inf_fields(&fields)
.unwrap()
.with_script(Some("on:hit { msg \"test\"; }".into()))
.with_description(Some("A place to build".into()));
assert_eq!(
obj.script.as_deref(),
Some("on:hit { msg \"test\"; }")
);
assert_eq!(obj.description.as_deref(), Some("A place to build"));
}
#[test]
fn test_serde_derives_compile() {
let obj = ObjectDef {
id: 1,
name: "test".into(),
group: "test".into(),
icon: None,
model: None,
behaviour: None,
scale: ObjectScale::default(),
color: None,
fx: None,
alpha: 1.0,
shininess: None,
auto_fade: 500,
detail_tex: None,
collision_mode: CollisionMode::Normal,
material: "wood".into(),
health: 100.0,
health_change: None,
sway_speed: None,
sway_power: 1.0,
max_weight: 100000,
state: ObjectState::Random,
align: 0,
search_ratio: 30.0,
grow_time: 10,
spawn: None,
harvest: vec![],
script: None,
description: None,
in_editor: true,
};
assert_eq!(obj.id, 1);
}
}