use std::collections::HashMap;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ItemGroup {
Material,
Food,
Stuff,
Tool,
Weapon,
Ammo,
Potion,
#[serde(untagged)]
Custom(String),
}
impl ItemGroup {
#[must_use]
pub fn from_inf(s: &str) -> Self {
match s.trim() {
"material" => Self::Material,
"food" => Self::Food,
"stuff" => Self::Stuff,
"tool" => Self::Tool,
"weapon" => Self::Weapon,
"ammo" => Self::Ammo,
"potion" => Self::Potion,
other => Self::Custom(other.to_owned()),
}
}
#[must_use]
pub fn as_str(&self) -> &str {
match self {
Self::Material => "material",
Self::Food => "food",
Self::Stuff => "stuff",
Self::Tool => "tool",
Self::Weapon => "weapon",
Self::Ammo => "ammo",
Self::Potion => "potion",
Self::Custom(s) => s.as_str(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Material {
Wood,
Stone,
Metal,
Flesh,
Fruit,
Leaf,
Glass,
Dust,
Water,
Dirt,
Cloth,
#[serde(rename = "none")]
None,
#[serde(untagged)]
Custom(String),
}
impl Material {
#[must_use]
pub fn from_inf(s: &str) -> Self {
match s.trim() {
"wood" => Self::Wood,
"stone" => Self::Stone,
"metal" => Self::Metal,
"flesh" => Self::Flesh,
"fruit" => Self::Fruit,
"leaf" => Self::Leaf,
"glass" => Self::Glass,
"dust" => Self::Dust,
"water" => Self::Water,
"dirt" => Self::Dirt,
"cloth" | "wool" => Self::Cloth,
"none" => Self::None,
other => Self::Custom(other.to_owned()),
}
}
#[must_use]
pub fn as_str(&self) -> &str {
match self {
Self::Wood => "wood",
Self::Stone => "stone",
Self::Metal => "metal",
Self::Flesh => "flesh",
Self::Fruit => "fruit",
Self::Leaf => "leaf",
Self::Glass => "glass",
Self::Dust => "dust",
Self::Water => "water",
Self::Dirt => "dirt",
Self::Cloth => "cloth",
Self::None => "none",
Self::Custom(s) => s.as_str(),
}
}
}
impl Default for ItemGroup {
fn default() -> Self {
Self::Material
}
}
impl Default for Material {
fn default() -> Self {
Self::None
}
}
impl std::fmt::Display for ItemGroup {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl std::fmt::Display for Material {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ItemDef {
pub id: u32,
pub name: String,
#[serde(default)]
pub group: ItemGroup,
pub icon: String,
#[serde(default)]
pub model: Option<String>,
#[serde(default)]
pub material: Material,
#[serde(default)]
pub weight: u32,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub color: Option<[u8; 3]>,
#[serde(default)]
pub scale: Option<f32>,
#[serde(default)]
pub fx: Option<u32>,
#[serde(default)]
pub alpha: Option<f32>,
#[serde(default)]
pub shininess: Option<f32>,
#[serde(default)]
pub blend: Option<u32>,
#[serde(default)]
pub durability: Option<f32>,
#[serde(default)]
pub health_change: Option<f32>,
#[serde(default)]
pub behaviour: Option<String>,
#[serde(default)]
pub damage: Option<String>,
#[serde(default)]
pub speed: Option<f32>,
#[serde(default)]
pub drag: Option<f32>,
#[serde(default)]
pub rate: Option<u32>,
#[serde(default)]
pub weapon_state: Option<String>,
#[serde(default)]
pub radius: Option<f32>,
#[serde(default)]
pub collision: Option<u32>,
}
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 first_str<'a>(fields: &'a HashMap<String, Vec<String>>, key: &str) -> Option<&'a str> {
fields.get(key)?.first().map(String::as_str)
}
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 first_string(fields: &HashMap<String, Vec<String>>, key: &str) -> Option<String> {
first_str(fields, key).map(ToOwned::to_owned)
}
impl ItemDef {
#[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 icon = first_string(fields, "icon")?;
let group = first_str(fields, "group")
.map(ItemGroup::from_inf)
.unwrap_or_default();
let model = first_string(fields, "model");
let material = first_str(fields, "mat")
.map(Material::from_inf)
.unwrap_or_default();
let weight = first_u32(fields, "weight")
.or_else(|| first_u32(fields, "w"))
.unwrap_or(0);
let description = first_string(fields, "info");
let color = first_str(fields, "color").and_then(parse_color);
let scale = first_f32(fields, "scale");
let fx = first_u32(fields, "fx");
let alpha = first_f32(fields, "alpha");
let shininess = first_f32(fields, "shine");
let blend = first_u32(fields, "blend");
let durability = first_f32(fields, "health");
let health_change = first_f32(fields, "healthchange");
let behaviour = first_string(fields, "behaviour");
let damage = first_string(fields, "damage");
let speed = first_f32(fields, "speed").or_else(|| first_f32(fields, "range"));
let drag = first_f32(fields, "drag");
let rate = first_u32(fields, "rate");
let weapon_state = first_string(fields, "weaponstate");
let radius = first_f32(fields, "radius");
let collision = first_u32(fields, "col");
Some(Self {
id,
name,
group,
icon,
model,
material,
weight,
description,
color,
scale,
fx,
alpha,
shininess,
blend,
durability,
health_change,
behaviour,
damage,
speed,
drag,
rate,
weapon_state,
radius,
collision,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_item_group_from_inf() {
assert_eq!(ItemGroup::from_inf("material"), ItemGroup::Material);
assert_eq!(ItemGroup::from_inf("food"), ItemGroup::Food);
assert_eq!(ItemGroup::from_inf("custom"), ItemGroup::Custom("custom".into()));
}
#[test]
fn test_item_group_as_str() {
assert_eq!(ItemGroup::Material.as_str(), "material");
assert_eq!(ItemGroup::Custom("quest".into()).as_str(), "quest");
}
#[test]
fn test_material_from_inf() {
assert_eq!(Material::from_inf("wood"), Material::Wood);
assert_eq!(Material::from_inf("stone"), Material::Stone);
assert_eq!(Material::from_inf("wool"), Material::Cloth);
assert_eq!(Material::from_inf("none"), Material::None);
assert_eq!(Material::from_inf("plastic"), Material::Custom("plastic".into()));
}
#[test]
fn test_material_as_str() {
assert_eq!(Material::Wood.as_str(), "wood");
assert_eq!(Material::Custom("rubber".into()).as_str(), "rubber");
}
#[test]
fn test_from_inf_fields_minimal() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["1".into()]);
fields.insert("name".into(), vec!["Bag".into()]);
fields.insert("icon".into(), vec!["gfx\\bag.bmp".into()]);
let item = ItemDef::from_inf_fields(&fields).unwrap();
assert_eq!(item.id, 1);
assert_eq!(item.name, "Bag");
assert_eq!(item.group, ItemGroup::Material);
assert_eq!(item.material, Material::None);
assert_eq!(item.weight, 0);
assert!(item.model.is_none());
}
#[test]
fn test_from_inf_fields_full() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["2".into()]);
fields.insert("name".into(), vec!["small Crystal".into()]);
fields.insert("group".into(), vec!["material".into()]);
fields.insert("icon".into(), vec!["gfx\\crystal01.bmp".into()]);
fields.insert("model".into(), vec!["gfx\\crystal01.b3d".into()]);
fields.insert("color".into(), vec!["0,255,0".into()]);
fields.insert("shine".into(), vec!["1".into()]);
fields.insert("blend".into(), vec!["3".into()]);
fields.insert("scale".into(), vec!["2".into()]);
fields.insert("mat".into(), vec!["stone".into()]);
fields.insert("weight".into(), vec!["200".into()]);
fields.insert("info".into(), vec!["a small crystal".into()]);
fields.insert("healthchange".into(), vec!["0".into()]);
let item = ItemDef::from_inf_fields(&fields).unwrap();
assert_eq!(item.id, 2);
assert_eq!(item.name, "small Crystal");
assert_eq!(item.group, ItemGroup::Material);
assert_eq!(item.icon, "gfx\\crystal01.bmp");
assert_eq!(item.model.as_deref(), Some("gfx\\crystal01.b3d"));
assert_eq!(item.color, Some([0, 255, 0]));
assert_eq!(item.shininess, Some(1.0));
assert_eq!(item.blend, Some(3));
assert_eq!(item.scale, Some(2.0));
assert_eq!(item.material, Material::Stone);
assert_eq!(item.weight, 200);
assert_eq!(item.description.as_deref(), Some("a small crystal"));
assert_eq!(item.health_change, Some(0.0));
}
#[test]
fn test_from_inf_fields_missing_id() {
let mut fields = HashMap::new();
fields.insert("name".into(), vec!["No ID".into()]);
fields.insert("icon".into(), vec!["icon.bmp".into()]);
assert!(ItemDef::from_inf_fields(&fields).is_none());
}
#[test]
fn test_parse_color() {
assert_eq!(parse_color("255,0,128"), Some([255, 0, 128]));
assert_eq!(parse_color("0,0,0"), Some([0, 0, 0]));
assert_eq!(parse_color("invalid"), None);
assert_eq!(parse_color("1,2"), None);
}
#[test]
fn test_from_inf_weapon_fields() {
let mut fields = HashMap::new();
fields.insert("id".into(), vec!["28".into()]);
fields.insert("name".into(), vec!["Machete".into()]);
fields.insert("group".into(), vec!["weapon".into()]);
fields.insert("icon".into(), vec!["gfx\\matchet.bmp".into()]);
fields.insert("model".into(), vec!["gfx\\matchet.b3d".into()]);
fields.insert("scale".into(), vec!["0.2".into()]);
fields.insert("behaviour".into(), vec!["blade".into()]);
fields.insert("mat".into(), vec!["metal".into()]);
fields.insert("weight".into(), vec!["1000".into()]);
fields.insert("damage".into(), vec!["9".into()]);
let item = ItemDef::from_inf_fields(&fields).unwrap();
assert_eq!(item.id, 28);
assert_eq!(item.group, ItemGroup::Weapon);
assert_eq!(item.behaviour.as_deref(), Some("blade"));
assert_eq!(item.damage.as_deref(), Some("9"));
assert_eq!(item.material, Material::Metal);
}
#[test]
fn test_display() {
assert_eq!(ItemGroup::Tool.to_string(), "tool");
assert_eq!(Material::Flesh.to_string(), "flesh");
}
#[test]
fn test_serde_derives_compile() {
let _ = ItemDef {
id: 1,
name: "test".into(),
group: ItemGroup::Material,
icon: "test.png".into(),
model: None,
material: Material::None,
weight: 0,
description: None,
color: None,
scale: None,
fx: None,
alpha: None,
shininess: None,
blend: None,
durability: None,
health_change: None,
behaviour: None,
damage: None,
speed: None,
drag: None,
rate: None,
weapon_state: None,
radius: None,
collision: None,
};
}
}