feat: add more names to new UI

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 February 2025
 
-* Add dagger names to new UI
+* Add belt, boots, bracers & dagger names to new UI
 * Monster changes
   * All spiders are now imps
   * Removed some not-so-fun monsters

src/data/item_name/main.rs

@@ -3,7 +3,9 @@ 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::belt::belt;
 use crate::data::item_name::subtype::boots::boots;
+use crate::data::item_name::subtype::bracers::bracers;
 use crate::data::item_name::subtype::chest::chest;
 use crate::data::item_name::subtype::gem::gem;
 use crate::data::item_name::subtype::jewelry::jewelry;
@@ -207,61 +209,6 @@ fn subtype_name<'a>(item: &Item) -> Cow<'a, str> {
             5 => "Set of cloth gloves",
             _ => "Alien gloves",
         }),
-        ItemType::Bracers => match item.subval {
-            1 => Cow::from(format!(
-                "Set of bracers{}",
-                if item.is_identified() {
-                    " of protection"
-                } else {
-                    ""
-                }
-            )),
-            2 => Cow::from(format!(
-                "Set of bracers{}",
-                if item.is_identified() {
-                    " of defence"
-                } else {
-                    ""
-                }
-            )),
-            3 => Cow::from(format!(
-                "Set of bracers{}",
-                if item.is_identified() {
-                    " of shielding"
-                } else {
-                    ""
-                }
-            )),
-            4 => Cow::from("Set of mithril bracers"),
-            5 => Cow::from("Set of adamantite bracers"),
-            6 => Cow::from(format!(
-                "Set of bracers{}",
-                if item.is_identified() {
-                    " of weapon attraction"
-                } else {
-                    ""
-                }
-            )),
-            30 => Cow::from("Small silver bracelet"),
-            31 => Cow::from(format!(
-                "Small silver bracelet{}",
-                if item.is_identified() {
-                    " of warding"
-                } else {
-                    ""
-                }
-            )),
-            40 => Cow::from("Small gold bracelet"),
-            50 => Cow::from("Small platinum bracelet"),
-            _ => Cow::from("Alien bracers"),
-        },
-        ItemType::Belt => Cow::from(match item.subval {
-            1 => "Girdle",
-            10 => "Silver belt buckle",
-            11 => "Gold belt buckle",
-            13 => "Leather belt",
-            _ => "Alien belt",
-        }),
         ItemType::Shield => Cow::from(match item.subval {
             1 => "Small leather shield",
             2 => "Medium leather shield",
@@ -675,6 +622,8 @@ pub fn generate(item: &Item) -> String {
         ItemType::Bag => bag(item),
         ItemType::Bolt => ammo(item),
         ItemType::Boots => boots(item),
+        ItemType::Belt => belt(item),
+        ItemType::Bracers => bracers(item),
         ItemType::Chest => chest(item),
         ItemType::Gem => gem(item),
         ItemType::HaftedWeapon | ItemType::Dagger => melee_weapon(item),

src/data/item_name/subtype.rs

@@ -12,3 +12,5 @@ pub mod wand;
 pub mod wearable_gem;
 pub mod melee_weapon;
 pub mod boots;
+pub mod belt;
+pub mod bracers;

src/data/item_name/subtype/belt.rs

@@ -0,0 +1,46 @@
+use crate::conversion::item_subtype;
+use crate::model::{Item, ItemType};
+use crate::model::item_subtype::{BeltSubType, ItemSubType};
+
+pub fn belt(item: &Item) -> String {
+    match item_subtype::from_i64(ItemType::Belt, item.subval) {
+        Some(item_subtype) => match item_subtype {
+            ItemSubType::Belt(belt_subtype) => match belt_subtype {
+                BeltSubType::Sash => "sash",
+                BeltSubType::LightBelt => "light belt",
+                BeltSubType::Belt => "belt",
+                BeltSubType::HeavyBelt => "heavy belt",
+                BeltSubType::LightPlatedBelt => "light plated belt",
+                BeltSubType::SharkskinBelt => "sharkskin belt",
+                BeltSubType::DemonhideBelt => "demonhide belt",
+                BeltSubType::WyrmhideBelt => "wyrmhide belt",
+            }
+            _ => "alien belt",
+        }
+        None => "alien belt",
+    }.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::data::item_name::generate;
+    use crate::generate_item;
+    use crate::generate_item::template::BeltTemplate;
+
+    #[test]
+    fn test_names() {
+        for (template, expected_name) in [
+            (Box::new(BeltTemplate::Sash), "sash"),
+            (Box::new(BeltTemplate::LightBelt), "light belt"),
+            (Box::new(BeltTemplate::Belt), "belt"),
+            (Box::new(BeltTemplate::HeavyBelt), "heavy belt"),
+            (Box::new(BeltTemplate::LightPlatedBelt), "light plated belt"),
+            (Box::new(BeltTemplate::SharkskinBelt), "sharkskin belt"),
+            (Box::new(BeltTemplate::DemonhideBelt), "demonhide belt"),
+            (Box::new(BeltTemplate::WyrmhideBelt), "wyrmhide belt"),
+        ] {
+            let item = generate_item::generate(template, 0);
+            assert_eq!(generate(&item), expected_name);
+        }
+    }
+}

src/data/item_name/subtype/boots.rs

@@ -1,6 +1,6 @@
 use crate::conversion::item_subtype;
-use crate::model::{Item, ItemType};
 use crate::model::item_subtype::{BootsSubType, ItemSubType};
+use crate::model::{Item, ItemType};
 
 pub fn boots(item: &Item) -> String {
     match item_subtype::from_i64(ItemType::Boots, item.subval) {
@@ -26,7 +26,7 @@ pub fn boots(item: &Item) -> String {
 mod tests {
     use crate::data::item_name::generate;
     use crate::generate_item;
-    use crate::generate_item::template::{BootsTemplate, MiscUsableTemplate};
+    use crate::generate_item::template::BootsTemplate;
 
     #[test]
     fn test_names() {

src/data/item_name/subtype/bracers.rs

@@ -0,0 +1,122 @@
+use crate::conversion::item_subtype;
+use crate::identification::is_identified;
+use crate::model::item_subtype::{BracersSubType, ItemSubType};
+use crate::model::{Item, ItemType};
+
+pub fn bracers(item: &Item) -> String {
+    let Some(item_subtype) = item_subtype::from_i64(ItemType::Bracers, item.subval) else {
+        return "alien bracers".to_string();
+    };
+
+    let subtype_is_known = is_identified(item_subtype);
+    match item_subtype {
+        ItemSubType::Bracers(bracers_subtype) => match bracers_subtype {
+            BracersSubType::BracersOfProtection => if subtype_is_known {
+                "bracers of protection"
+            } else {
+                "bracers"
+            },
+            BracersSubType::BracersOfDefense => if subtype_is_known {
+                "bracers of defense"
+            } else {
+                "bracers"
+            },
+            BracersSubType::BracersOfShielding => if subtype_is_known {
+                "bracers of shielding"
+            } else {
+                "bracers"
+            },
+            BracersSubType::MithrilBracers => "mithril bracers",
+            BracersSubType::AdamantiteBracers => "adamantite bracers",
+            BracersSubType::BracersOfWeaponAttraction => if subtype_is_known {
+                "bracers of weapon attraction"
+            } else {
+                "bracers"
+            },
+            BracersSubType::SilverBraceletOfWarding => if subtype_is_known {
+                "silver bracelet of warding"
+            } else {
+                "silver bracelet"
+            },
+            BracersSubType::SilverBracelet => "silver bracelet",
+            BracersSubType::GoldBracelet => "gold bracelet",
+            BracersSubType::PlatinumBracelet => "platinum bracelet",
+            BracersSubType::LeatherBracers => "leather bracers",
+            BracersSubType::StuddedLeatherBracers => "studded leather bracers",
+            BracersSubType::LightPlatedBracers => "light plated bracers",
+            BracersSubType::SharkskinBracers => "sharkskin bracers",
+            BracersSubType::DemonhideBracers => "demonhide bracers",
+            BracersSubType::WyrmhideBracers => "wymhide bracers",
+            BracersSubType::ChainmailBracers => "chainmail bracers",
+            BracersSubType::LamellarBracers => "lamellar bracers",
+        }
+        _ => "alien bracers",
+    }.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::data::item_name::generate;
+    use crate::generate_item::template::BracersTemplate;
+    use crate::generate_item::ItemTemplate;
+    use crate::{generate_item, identification};
+    use serial_test::serial;
+
+    #[test]
+    #[serial]
+    fn test_names_unidentified_type() {
+        for (template, expected_name) in [
+            (Box::new(BracersTemplate::BracersOfProtection), "bracers"),
+            (Box::new(BracersTemplate::BracersOfDefense), "bracers"),
+            (Box::new(BracersTemplate::BracersOfShielding), "bracers"),
+            (Box::new(BracersTemplate::MithrilBracers), "mithril bracers"),
+            (Box::new(BracersTemplate::AdamantiteBracers), "adamantite bracers"),
+            (Box::new(BracersTemplate::BracersOfWeaponAttraction), "bracers"),
+            (Box::new(BracersTemplate::SilverBraceletOfWarding), "silver bracelet"),
+            (Box::new(BracersTemplate::SilverBracelet), "silver bracelet"),
+            (Box::new(BracersTemplate::GoldBracelet), "gold bracelet"),
+            (Box::new(BracersTemplate::PlatinumBracelet), "platinum bracelet"),
+            (Box::new(BracersTemplate::LeatherBracers), "leather bracers"),
+            (Box::new(BracersTemplate::StuddedLeatherBracers), "studded leather bracers"),
+            (Box::new(BracersTemplate::LightPlatedBracers), "light plated bracers"),
+            (Box::new(BracersTemplate::SharkskinBracers), "sharkskin bracers"),
+            (Box::new(BracersTemplate::DemonhideBracers), "demonhide bracers"),
+            (Box::new(BracersTemplate::WyrmhideBracers), "wymhide bracers"),
+            (Box::new(BracersTemplate::ChainmailBracers), "chainmail bracers"),
+            (Box::new(BracersTemplate::LamellarBracers), "lamellar bracers"),
+        ] {
+            let item = generate_item::generate(template.clone(), 0);
+            identification::set_identified(template.subtype(), false);
+            assert_eq!(generate(&item), expected_name);
+        }
+    }
+
+    #[test]
+    #[serial]
+    fn test_names_identified_type() {
+        for (template, expected_name) in [
+            (Box::new(BracersTemplate::BracersOfProtection), "bracers of protection"),
+            (Box::new(BracersTemplate::BracersOfDefense), "bracers of defense"),
+            (Box::new(BracersTemplate::BracersOfShielding), "bracers of shielding"),
+            (Box::new(BracersTemplate::MithrilBracers), "mithril bracers"),
+            (Box::new(BracersTemplate::AdamantiteBracers), "adamantite bracers"),
+            (Box::new(BracersTemplate::BracersOfWeaponAttraction), "bracers of weapon attraction"),
+            (Box::new(BracersTemplate::SilverBraceletOfWarding), "silver bracelet of warding"),
+            (Box::new(BracersTemplate::SilverBracelet), "silver bracelet"),
+            (Box::new(BracersTemplate::GoldBracelet), "gold bracelet"),
+            (Box::new(BracersTemplate::PlatinumBracelet), "platinum bracelet"),
+            (Box::new(BracersTemplate::LeatherBracers), "leather bracers"),
+            (Box::new(BracersTemplate::StuddedLeatherBracers), "studded leather bracers"),
+            (Box::new(BracersTemplate::LightPlatedBracers), "light plated bracers"),
+            (Box::new(BracersTemplate::SharkskinBracers), "sharkskin bracers"),
+            (Box::new(BracersTemplate::DemonhideBracers), "demonhide bracers"),
+            (Box::new(BracersTemplate::WyrmhideBracers), "wymhide bracers"),
+            (Box::new(BracersTemplate::ChainmailBracers), "chainmail bracers"),
+            (Box::new(BracersTemplate::LamellarBracers), "lamellar bracers"),
+        ] {
+            let item = generate_item::generate(template.clone(), 0);
+            identification::set_identified(template.subtype(), true);
+            assert_eq!(generate(&item), expected_name);
+        }
+    }
+}