damage mod multiplier unit tests

src/components.rs

@@ -392,12 +392,17 @@ pub enum DamageModifier {
 }
 
 impl DamageModifier {
+    const NONE_MOD: f32 = 1.0;
+    const WEAK_MOD: f32 = 2.0;
+    const RESIST_MOD: f32 = 0.5;
+    const IMMUNE_MOD: f32 = 0.0;
+
     pub fn multiplier(&self) -> f32 {
         match self {
-            DamageModifier::None => 1.0,
+            DamageModifier::None => Self::NONE_MOD,
-            DamageModifier::Weakness => 10.0,
+            DamageModifier::Weakness => Self::WEAK_MOD,
-            DamageModifier::Resistance => 0.5,
+            DamageModifier::Resistance => Self::RESIST_MOD,
-            DamageModifier::Immune => 0.0,
+            DamageModifier::Immune => Self::IMMUNE_MOD,
         }
     }
 }

tests/components_test.rs

@@ -1,5 +1,6 @@
 // tests/components_test.rs
 use rust_rl::components::*;
+use std::collections::HashMap;
 
 #[test]
 fn damagetype_equality() {
@@ -17,3 +18,30 @@ fn damagetype_ismagic() {
     assert!(!dt1.is_magic());
     assert!(dt2.is_magic());
 }
+
+#[test]
+fn get_damage_modifiers() {
+    let dm = HasDamageModifiers {
+        modifiers: {
+            let mut m = HashMap::new();
+            m.insert(DamageType::Physical, DamageModifier::Weakness);
+            m.insert(DamageType::Magic, DamageModifier::Resistance);
+            m
+        },
+    };
+    assert_eq!(dm.modifier(&DamageType::Physical), &DamageModifier::Weakness);
+    assert_eq!(dm.modifier(&DamageType::Magic), &DamageModifier::Resistance);
+    assert_ne!(dm.modifier(&DamageType::Forced), &DamageModifier::Immune);
+}
+
+#[test]
+fn get_damage_modifier_multiplier() {
+    let none_mod = &DamageModifier::None.multiplier();
+    let weak_mod = &DamageModifier::Weakness.multiplier();
+    let res_mod = &DamageModifier::Resistance.multiplier();
+    let immune_mod = &DamageModifier::Immune.multiplier();
+    assert_eq!(none_mod, &1.0);
+    assert_eq!(weak_mod, &2.0);
+    assert_eq!(res_mod, &0.5);
+    assert_eq!(immune_mod, &0.0);
+}