atomising item use: hunger effect

src/effects/hunger.rs

@@ -0,0 +1,12 @@
+use super::EffectSpawner;
+use crate::{HungerClock, HungerState};
+use specs::prelude::*;
+
+const SATIATED_DURATION: i32 = 200;
+
+pub fn restore_food(ecs: &mut World, _damage: &EffectSpawner, target: Entity) {
+    if let Some(hc) = ecs.write_storage::<HungerClock>().get_mut(target) {
+        hc.state = HungerState::Satiated;
+        hc.duration = SATIATED_DURATION;
+    }
+}

src/effects/mod.rs

@@ -5,10 +5,13 @@ use std::collections::VecDeque;
 use std::sync::Mutex;
 
 mod damage;
+mod hunger;
 mod particles;
 mod targeting;
 mod triggers;
 
+pub use targeting::aoe_tiles;
+
 lazy_static! {
     pub static ref EFFECT_QUEUE: Mutex<VecDeque<EffectSpawner>> = Mutex::new(VecDeque::new());
 }
@@ -19,6 +22,7 @@ pub enum EffectType {
     Particle { glyph: FontCharType, fg: RGB, bg: RGB, lifespan: f32, delay: f32 },
     EntityDeath,
     ItemUse { item: Entity },
+    RestoreNutrition,
 }
 
 #[derive(Clone)]
@@ -70,14 +74,6 @@ fn target_applicator(ecs: &mut World, effect: &EffectSpawner) {
     }
 }
 
-/// Checks if a given effect affects entities or not.
-fn tile_effect_hits_entities(effect: &EffectType) -> bool {
-    match effect {
-        EffectType::Damage { .. } => true,
-        _ => false,
-    }
-}
-
 /// Runs an effect on a given tile index
 fn affect_tile(ecs: &mut World, effect: &EffectSpawner, target: usize) {
     if tile_effect_hits_entities(&effect.effect_type) {
@@ -94,6 +90,15 @@ fn affect_tile(ecs: &mut World, effect: &EffectSpawner, target: usize) {
     // Run the effect
 }
 
+/// Checks if a given effect affects entities or not.
+fn tile_effect_hits_entities(effect: &EffectType) -> bool {
+    match effect {
+        EffectType::Damage { .. } => true,
+        EffectType::RestoreNutrition => true,
+        _ => false,
+    }
+}
+
 /// Runs an effect on a given entity
 fn affect_entity(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
     match &effect.effect_type {
@@ -109,6 +114,7 @@ fn affect_entity(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
             }
         }
         EffectType::EntityDeath => damage::entity_death(ecs, effect, target),
+        EffectType::RestoreNutrition => hunger::restore_food(ecs, effect, target),
         _ => {}
     }
 }

src/effects/targeting.rs

@@ -8,3 +8,13 @@ pub fn entity_position(ecs: &World, target: Entity) -> Option<usize> {
     }
     return None;
 }
+
+pub fn aoe_tiles(map: &Map, target: rltk::Point, radius: i32) -> Vec<usize> {
+    let mut blast_tiles = rltk::field_of_view(target, radius, &*map);
+    blast_tiles.retain(|p| p.x > 0 && p.x < map.width - 1 && p.y > 0 && p.y < map.height - 1);
+    let mut result = Vec::new();
+    for t in blast_tiles.iter() {
+        result.push(map.xy_idx(t.x, t.y));
+    }
+    result
+}

src/effects/triggers.rs

@@ -1,5 +1,5 @@
-use super::{Entity, Targets, World};
-use crate::{gamelog, Consumable};
+use super::{add_effect, EffectType, Entity, Targets, World};
+use crate::{gamelog, gui::item_colour_ecs, gui::obfuscate_name, Consumable, ProvidesNutrition};
 use specs::prelude::*;
 
 pub fn item_trigger(source: Option<Entity>, item: Entity, target: &Targets, ecs: &mut World) {
@@ -12,5 +12,15 @@ pub fn item_trigger(source: Option<Entity>, item: Entity, target: &Targets, ecs:
 }
 
 fn event_trigger(source: Option<Entity>, entity: Entity, target: &Targets, ecs: &mut World) {
-    let logger = gamelog::Logger::new();
+    let mut logger = gamelog::Logger::new();
+    // Providing nutrition
+    if ecs.read_storage::<ProvidesNutrition>().get(entity).is_some() {
+        add_effect(source, EffectType::RestoreNutrition, target.clone());
+        logger = logger
+            .append("You eat the")
+            .append_n(obfuscate_name(ecs, entity).0)
+            .colour(item_colour_ecs(ecs, entity))
+            .period();
+    }
+    logger.log();
 }