InflictsDamage and ProvidesHealing now use dice rolls

src/components.rs

@@ -311,12 +311,16 @@ pub struct Cursed {}
 
 #[derive(Component, Debug, ConvertSaveload, Clone)]
 pub struct ProvidesHealing {
-    pub amount: i32,
+    pub n_dice: i32,
+    pub sides: i32,
+    pub modifier: i32,
 }
 
 #[derive(Component, Debug, ConvertSaveload, Clone)]
 pub struct InflictsDamage {
-    pub amount: i32,
+    pub n_dice: i32,
+    pub sides: i32,
+    pub modifier: i32,
 }
 
 #[derive(Component, Debug, ConvertSaveload, Clone)]

src/inventory_system.rs

@@ -125,7 +125,6 @@ impl<'a> System<'a> for ItemUseSystem {
             let is_cursed = cursed_items.get(wants_to_use.item);
             let wand = wands.get_mut(wants_to_use.item);
             if let Some(wand) = wand {
-                let name = names.get_mut(wants_to_use.item).unwrap();
                 // If want has no uses, roll 1d121. On a 121, wrest the wand, then delete it.
                 if wand.uses == 0 {
                     if rng.roll_dice(1, 121) != 121 {
@@ -269,8 +268,8 @@ impl<'a> System<'a> for ItemUseSystem {
                     for target in targets.iter() {
                         let stats = combat_stats.get_mut(*target);
                         if let Some(stats) = stats {
-                            stats.hit_points.current =
-                                i32::min(stats.hit_points.max, stats.hit_points.current + heal.amount);
+                            let roll = rng.roll_dice(heal.n_dice, heal.sides) + heal.modifier;
+                            stats.hit_points.current = i32::min(stats.hit_points.max, stats.hit_points.current + roll);
                             if entity == *player_entity {
                                 logger = logger.append("You recover some vigour.");
                             }
@@ -292,6 +291,7 @@ impl<'a> System<'a> for ItemUseSystem {
                 None => {}
                 Some(damage) => {
                     let target_point = wants_to_use.target.unwrap();
+                    let damage_roll = rng.roll_dice(damage.n_dice, damage.sides) + damage.modifier;
                     if !aoe_item {
                         particle_builder.request_rainbow_star(
                             target_point.x,
@@ -305,7 +305,7 @@ impl<'a> System<'a> for ItemUseSystem {
                         let entity_name = names.get(*mob).unwrap();
                         match destructible {
                             None => {
-                                SufferDamage::new_damage(&mut suffer_damage, *mob, damage.amount, true);
+                                SufferDamage::new_damage(&mut suffer_damage, *mob, damage_roll, true);
                                 if entity == *player_entity {
                                     damage_logger =
                                         damage_logger.append("The").npc_name(&entity_name.name).append("is hit!");

src/raws/rawmaster.rs

@@ -159,9 +159,15 @@ pub fn spawn_named_item(raws: &RawMaster, ecs: &mut World, key: &str, pos: Spawn
             for effect in effects_list.iter() {
                 let effect_name = effect.0.as_str();
                 match effect_name {
-                    "provides_healing" => eb = eb.with(ProvidesHealing { amount: effect.1.parse::<i32>().unwrap() }),
+                    "provides_healing" => {
+                        let (n_dice, sides, modifier) = parse_dice_string(effect.1.as_str());
+                        eb = eb.with(ProvidesHealing { n_dice, sides, modifier })
+                    }
                     "ranged" => eb = eb.with(Ranged { range: effect.1.parse::<i32>().unwrap() }),
-                    "damage" => eb = eb.with(InflictsDamage { amount: effect.1.parse::<i32>().unwrap() }),
+                    "damage" => {
+                        let (n_dice, sides, modifier) = parse_dice_string(effect.1.as_str());
+                        eb = eb.with(InflictsDamage { n_dice, sides, modifier })
+                    }
                     "aoe" => eb = eb.with(AOE { radius: effect.1.parse::<i32>().unwrap() }),
                     "confusion" => eb = eb.with(Confusion { turns: effect.1.parse::<i32>().unwrap() }),
                     "base_damage" => base_damage = effect.1,
@@ -480,7 +486,10 @@ pub fn spawn_named_prop(raws: &RawMaster, ecs: &mut World, key: &str, pos: Spawn
             for effect in effects_list.iter() {
                 let effect_name = effect.0.as_str();
                 match effect_name {
-                    "damage" => eb = eb.with(InflictsDamage { amount: effect.1.parse::<i32>().unwrap() }),
+                    "damage" => {
+                        let (n_dice, sides, modifier) = parse_dice_string(effect.1.as_str());
+                        eb = eb.with(ProvidesHealing { n_dice, sides, modifier })
+                    }
                     "confusion" => eb = eb.with(Confusion { turns: effect.1.parse::<i32>().unwrap() }),
                     _ => rltk::console::log(format!("Warning: effect {} not implemented.", effect_name)),
                 }

src/trigger_system.rs

@@ -61,13 +61,9 @@ impl<'a> System<'a> for TriggerSystem {
 
                             let damage = inflicts_damage.get(*entity_id);
                             if let Some(damage) = damage {
+                                let damage_roll = rng.roll_dice(damage.n_dice, damage.sides) + damage.modifier;
                                 particle_builder.damage_taken(pos.x, pos.y);
-                                SufferDamage::new_damage(
-                                    &mut inflict_damage,
-                                    entity,
-                                    rng.roll_dice(1, damage.amount),
-                                    false,
-                                );
+                                SufferDamage::new_damage(&mut inflict_damage, entity, damage_roll, false);
                             }
 
                             let confuses = confusion.get(*entity_id);