feat: port boots names

src/data/item_name/main.rs

@@ -3,6 +3,7 @@ use std::borrow::Cow;
 use crate::data;
 use crate::data::item_name::subtype::ammo::ammo;
 use crate::data::item_name::subtype::bag::bag;
+use crate::data::item_name::subtype::boots::boots;
 use crate::data::item_name::subtype::chest::chest;
 use crate::data::item_name::subtype::gem::gem;
 use crate::data::item_name::subtype::jewelry::jewelry;
@@ -136,13 +137,6 @@ fn subtype_name<'a>(item: &Item) -> Cow<'a, str> {
             7 => "Orcish pick",
             _ => "Alien pick",
         }),
-        ItemType::Boots => Cow::from(match item.subval {
-            1 => "Pair of soft leather shoes",
-            2 => "Pair of soft leather boots",
-            3 => "Pair of hard leather boots",
-            4 => "Pair of sandals",
-            _ => "Alien boots",
-        }),
         ItemType::Helm => Cow::from(match item.subval {
             12 => "Cloth hat",
             13 => "Soft leather cap",
@@ -680,6 +674,7 @@ pub fn generate(item: &Item) -> String {
         ItemType::Arrow => ammo(item),
         ItemType::Bag => bag(item),
         ItemType::Bolt => ammo(item),
+        ItemType::Boots => boots(item),
         ItemType::Chest => chest(item),
         ItemType::Gem => gem(item),
         ItemType::HaftedWeapon | ItemType::Dagger => melee_weapon(item),

src/data/item_name/subtype.rs

@@ -11,3 +11,4 @@ pub mod spike;
 pub mod wand;
 pub mod wearable_gem;
 pub mod melee_weapon;
+pub mod boots;

src/data/item_name/subtype/boots.rs

@@ -0,0 +1,48 @@
+use crate::conversion::item_subtype;
+use crate::model::{Item, ItemType};
+use crate::model::item_subtype::{BootsSubType, ItemSubType};
+
+pub fn boots(item: &Item) -> String {
+    match item_subtype::from_i64(ItemType::Boots, item.subval) {
+        Some(item_subtype) => match item_subtype {
+            ItemSubType::Boots(boots_subtype) => match boots_subtype {
+                BootsSubType::SoftLeatherShoes => "soft leather shoes",
+                BootsSubType::SoftLeatherBoots => "soft leather boots",
+                BootsSubType::HardLeatherBoots => "hard leather boots",
+                BootsSubType::Sandals => "sandals",
+                BootsSubType::ChainBoots => "chain boots",
+                BootsSubType::LightPlatedBoots => "light plated boots",
+                BootsSubType::SharkskinBoots => "sharkskin boots",
+                BootsSubType::DemonhideBoots => "demonhide boots",
+                BootsSubType::WyrmhideBoot => "wyrmhide boots",
+            }
+            _ => "alien boots",
+        }
+        None => "alien boots",
+    }.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::data::item_name::generate;
+    use crate::generate_item;
+    use crate::generate_item::template::{BootsTemplate, MiscUsableTemplate};
+
+    #[test]
+    fn test_names() {
+        for (template, expected_name) in [
+            (Box::new(BootsTemplate::SoftLeatherShoes), "soft leather shoes"),
+            (Box::new(BootsTemplate::SoftLeatherBoots), "soft leather boots"),
+            (Box::new(BootsTemplate::HardLeatherBoots), "hard leather boots"),
+            (Box::new(BootsTemplate::Sandals), "sandals"),
+            (Box::new(BootsTemplate::ChainBoots), "chain boots"),
+            (Box::new(BootsTemplate::LightPlatedBoots), "light plated boots"),
+            (Box::new(BootsTemplate::SharkskinBoots), "sharkskin boots"),
+            (Box::new(BootsTemplate::DemonhideBoots), "demonhide boots"),
+            (Box::new(BootsTemplate::WyrmhideBoot), "wyrmhide boots"),
+        ] {
+            let item = generate_item::generate(template, 0);
+            assert_eq!(generate(&item), expected_name);
+        }
+    }
+}

src/data/item_name/subtype/light_source.rs

@@ -10,16 +10,16 @@ pub fn light_source(item: &Item) -> String {
         match from_i64(ItemType::LightSource, item.subval) {
             Some(subtype) => match subtype {
                 ItemSubType::LightSource(LightSourceSubType::WoodenTorch) => {
-                    Cow::from("Wooden torch")
+                    Cow::from("wooden torch")
                 }
                 ItemSubType::LightSource(LightSourceSubType::BrassLantern) => {
-                    Cow::from("Brass lantern")
+                    Cow::from("brass lantern")
                 }
                 ItemSubType::LightSource(LightSourceSubType::MagicTorch) => {
-                    Cow::from("Magic torch")
+                    Cow::from("magic torch")
                 }
                 ItemSubType::LightSource(LightSourceSubType::MagicLantern) => {
-                    Cow::from("Magic lantern")
+                    Cow::from("magic lantern")
                 }
                 t => panic!("Expected light source, got {:?}", t),
             },
@@ -43,10 +43,10 @@ mod tests {
     #[test]
     fn test_light_source_wooden_torch() {
         let mut item = generate_item::generate(Box::new(LightSourceTemplate::WoodenTorch), 0);
-        assert_eq!(generate(&item), "Wooden torch with 4000 turns of light");
+        assert_eq!(generate(&item), "wooden torch with 4000 turns of light");
 
         item.p1 = 1;
-        assert_eq!(generate(&item), "Wooden torch with 1 turn of light");
+        assert_eq!(generate(&item), "wooden torch with 1 turn of light");
     }
 
     #[test]
@@ -56,7 +56,7 @@ mod tests {
                 Box::new(LightSourceTemplate::BrassLantern),
                 0
             )),
-            "Brass lantern with 7500 turns of light"
+            "brass lantern with 7500 turns of light"
         );
     }
 
@@ -66,13 +66,13 @@ mod tests {
         magic_torch.set_identified(true);
         assert_eq!(
             generate(&magic_torch),
-            "Magic torch with 9000 turns of light"
+            "magic torch with 9000 turns of light"
         );
 
         magic_torch.set_identified(false);
         assert_eq!(
             generate(&magic_torch),
-            "Magic torch with 9000 turns of light"
+            "magic torch with 9000 turns of light"
         );
     }
 
@@ -83,13 +83,13 @@ mod tests {
         magic_lantern.set_identified(true);
         assert_eq!(
             generate(&magic_lantern),
-            "Magic lantern with 20000 turns of light"
+            "magic lantern with 20000 turns of light"
         );
 
         magic_lantern.set_identified(false);
         assert_eq!(
             generate(&magic_lantern),
-            "Magic lantern with 20000 turns of light"
+            "magic lantern with 20000 turns of light"
         );
     }
 }

src/data/item_name/subtype/melee_weapon.rs

@@ -21,40 +21,40 @@ fn subtype_name(item: &Item) -> String {
     match item.item_type() {
         ItemType::Dagger => {
             match dagger::from_usize(item.subval as usize) {
-                None => "Alien dagger",
+                None => "alien dagger",
                 Some(subtype) => match subtype {
-                    DaggerSubType::MainGauche => "Main gauche",
-                    DaggerSubType::Misercorde => "Misercorde",
-                    DaggerSubType::Stiletto => "Stiletto",
-                    DaggerSubType::Bodkin => "Bodkin",
-                    DaggerSubType::BrokenDagger => "Broken dagger",
-                    DaggerSubType::CatONineTails => "Cat-o-nine tails",
-                    DaggerSubType::Bilbo => "Bilbo",
-                    DaggerSubType::Baselard => "Baselard",
-                    DaggerSubType::Foil => "Foil",
-                    DaggerSubType::Rapier => "Rapier",
-                    DaggerSubType::SmallSword => "Small sword",
+                    DaggerSubType::MainGauche => "main gauche",
+                    DaggerSubType::Misercorde => "misercorde",
+                    DaggerSubType::Stiletto => "stiletto",
+                    DaggerSubType::Bodkin => "bodkin",
+                    DaggerSubType::BrokenDagger => "broken dagger",
+                    DaggerSubType::CatONineTails => "cat-o-nine tails",
+                    DaggerSubType::Bilbo => "bilbo",
+                    DaggerSubType::Baselard => "baselard",
+                    DaggerSubType::Foil => "foil",
+                    DaggerSubType::Rapier => "rapier",
+                    DaggerSubType::SmallSword => "small sword",
                 },
             }
         }.to_string(),
         ItemType::HaftedWeapon => {
             match hafted_weapon::from_usize(item.subval as usize) {
-                None => "Alien hafted weapon",
+                None => "alien hafted weapon",
                 Some(subtype) => match subtype {
-                    HaftedWeaponSubType::Balestarius => "Balestarius",
-                    HaftedWeaponSubType::BattleAxe => "Battle axe",
-                    HaftedWeaponSubType::BroadAxe => "Broad axe",
-                    HaftedWeaponSubType::HandAxe => "Hand axe",
-                    HaftedWeaponSubType::WarAxe => "War axe",
-                    HaftedWeaponSubType::LargeAxe => "Large axe",
-                    HaftedWeaponSubType::BeardedAxe => "Bearded axe",
-                    HaftedWeaponSubType::SilverEdgedAxe => "Silver edged axe",
-                    HaftedWeaponSubType::ChampionAxe => "Champion axe",
+                    HaftedWeaponSubType::Balestarius => "balestarius",
+                    HaftedWeaponSubType::BattleAxe => "battle axe",
+                    HaftedWeaponSubType::BroadAxe => "broad axe",
+                    HaftedWeaponSubType::HandAxe => "hand axe",
+                    HaftedWeaponSubType::WarAxe => "war axe",
+                    HaftedWeaponSubType::LargeAxe => "large axe",
+                    HaftedWeaponSubType::BeardedAxe => "bearded axe",
+                    HaftedWeaponSubType::SilverEdgedAxe => "silver edged axe",
+                    HaftedWeaponSubType::ChampionAxe => "champion axe",
                 },
             }
         }
         .to_string(),
-        _ => "Alien weapon".to_string(),
+        _ => "alien weapon".to_string(),
     }
 }
 
@@ -69,18 +69,18 @@ mod tests {
         let mut item = generate_item::generate(Box::new(AxeTemplate::Balestarius), 0);
 
         item.set_identified(false);
-        assert_eq!(generate(&item), "Balestarius (2d8)");
+        assert_eq!(generate(&item), "balestarius (2d8)");
 
         item.set_identified(true);
-        assert_eq!(generate(&item), "Balestarius (2d8) (0,0)");
+        assert_eq!(generate(&item), "balestarius (2d8) (0,0)");
 
         item.tohit = 1;
         item.todam = 2;
-        assert_eq!(generate(&item), "Balestarius (2d8) (+1,+2)");
+        assert_eq!(generate(&item), "balestarius (2d8) (+1,+2)");
 
         item.tohit = -1;
         item.todam = -2;
-        assert_eq!(generate(&item), "Balestarius (2d8) (-1,-2)");
+        assert_eq!(generate(&item), "balestarius (2d8) (-1,-2)");
     }
 
     #[test]
@@ -90,51 +90,51 @@ mod tests {
                 Box::new(AxeTemplate::Balestarius),
                 0
             )),
-            "Balestarius (2d8)"
+            "balestarius (2d8)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(AxeTemplate::BattleAxe),
                 0
             )),
-            "Battle axe (3d4)"
+            "battle axe (3d4)"
         );
         assert_eq!(
             generate(&generate_item::generate(Box::new(AxeTemplate::BroadAxe), 0)),
-            "Broad axe (2d6)"
+            "broad axe (2d6)"
         );
         assert_eq!(
             generate(&generate_item::generate(Box::new(AxeTemplate::HandAxe), 0)),
-            "Hand axe (1d4)"
+            "hand axe (1d4)"
         );
         assert_eq!(
             generate(&generate_item::generate(Box::new(AxeTemplate::WarAxe), 0)),
-            "War axe (1d6)"
+            "war axe (1d6)"
         );
         assert_eq!(
             generate(&generate_item::generate(Box::new(AxeTemplate::LargeAxe), 0)),
-            "Large axe (1d9)"
+            "large axe (1d9)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(AxeTemplate::BeardedAxe),
                 0
             )),
-            "Bearded axe (2d5)"
+            "bearded axe (2d5)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(AxeTemplate::SilverEdgedAxe),
                 0
             )),
-            "Silver edged axe (3d6)"
+            "silver edged axe (3d6)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(AxeTemplate::ChampionAxe),
                 0
             )),
-            "Champion axe (5d3)"
+            "champion axe (5d3)"
         );
     }
 
@@ -145,77 +145,77 @@ mod tests {
                 Box::new(DaggerTemplate::MainGauche),
                 0
             )),
-            "Main gauche (1d5)"
+            "main gauche (1d5)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::Misercorde),
                 0
             )),
-            "Misercorde (1d4)"
+            "misercorde (1d4)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::Stiletto),
                 0
             )),
-            "Stiletto (1d4)"
+            "stiletto (1d4)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::Bodkin),
                 0
             )),
-            "Bodkin (1d4)"
+            "bodkin (1d4)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::BrokenDagger),
                 0
             )),
-            "Broken dagger (1d1)"
+            "broken dagger (1d1)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::CatONineTails),
                 0
             )),
-            "Cat-o-nine tails (1d4)"
+            "cat-o-nine tails (1d4)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::Bilbo),
                 0
             )),
-            "Bilbo (1d6)"
+            "bilbo (1d6)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::Baselard),
                 0
             )),
-            "Baselard (1d7)"
+            "baselard (1d7)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::Foil),
                 0
             )),
-            "Foil (1d5)"
+            "foil (1d5)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::Rapier),
                 0
             )),
-            "Rapier (1d6)"
+            "rapier (1d6)"
         );
         assert_eq!(
             generate(&generate_item::generate(
                 Box::new(DaggerTemplate::SmallSword),
                 0
             )),
-            "Small sword (1d6)"
+            "small sword (1d6)"
         );
     }
 }