deletes deprecated damage system

src/ai/turn_status_system.rs

@@ -35,7 +35,6 @@ impl<'a> System<'a> for TurnStatusSystem {
         let mut not_my_turn: Vec<Entity> = Vec::new();
         let mut not_confused: Vec<Entity> = Vec::new();
         for (entity, _turn, confused, name) in (&entities, &mut turns, &mut confusion, &names).join() {
-            log = true;
             confused.turns -= 1;
             if confused.turns < 1 {
                 not_confused.push(entity);
@@ -45,6 +44,7 @@ impl<'a> System<'a> for TurnStatusSystem {
                         .append(&name.name)
                         .colour(WHITE)
                         .append("snap out of it.");
+                    log = true;
                 } else {
                     logger = logger
                         .append("The")
@@ -52,6 +52,7 @@ impl<'a> System<'a> for TurnStatusSystem {
                         .append(&name.name)
                         .colour(WHITE)
                         .append("snaps out of it.");
+                    log = true;
                 }
                 add_effect(
                     None,
@@ -72,6 +73,8 @@ impl<'a> System<'a> for TurnStatusSystem {
                         .append(&name.name)
                         .colour(WHITE)
                         .append("are confused!");
+                    log = true;
+                    gamelog::record_event("player_confused", 1);
                 } else {
                     logger = logger
                         .append("The")
@@ -79,6 +82,7 @@ impl<'a> System<'a> for TurnStatusSystem {
                         .append(&name.name)
                         .colour(WHITE)
                         .append("is confused!");
+                    log = true;
                 }
                 add_effect(
                     None,

src/damage_system.rs

@@ -6,118 +6,6 @@ use crate::gamesystem::{hp_per_level, mana_per_level};
 use rltk::prelude::*;
 use specs::prelude::*;
 
-pub struct DamageSystem {}
-
-impl<'a> System<'a> for DamageSystem {
-    #[allow(clippy::type_complexity)]
-    type SystemData = (
-        WriteStorage<'a, Pools>,
-        WriteStorage<'a, SufferDamage>,
-        ReadStorage<'a, Position>,
-        WriteExpect<'a, Map>,
-        Entities<'a>,
-        ReadExpect<'a, Entity>,
-        ReadStorage<'a, Attributes>,
-        WriteExpect<'a, rltk::RandomNumberGenerator>,
-        ReadStorage<'a, GrantsXP>,
-        WriteExpect<'a, ParticleBuilder>,
-        ReadExpect<'a, rltk::Point>,
-    );
-
-    fn run(&mut self, data: Self::SystemData) {
-        let (
-            mut stats,
-            mut damage,
-            positions,
-            mut map,
-            entities,
-            player,
-            attributes,
-            mut rng,
-            xp_granters,
-            mut particle_builder,
-            player_pos,
-        ) = data;
-        let mut xp_gain = 0;
-
-        for (entity, mut stats, damage) in (&entities, &mut stats, &damage).join() {
-            for dmg in damage.amount.iter() {
-                if !stats.god {
-                    stats.hit_points.current -= dmg.0;
-                }
-                let pos = positions.get(entity);
-                if let Some(pos) = pos {
-                    let idx = map.xy_idx(pos.x, pos.y);
-                    map.bloodstains.insert(idx);
-                }
-
-                if stats.hit_points.current < 1 && dmg.1 {
-                    let gives_xp = xp_granters.get(entity);
-                    if let Some(xp_value) = gives_xp {
-                        xp_gain += xp_value.amount;
-                    }
-                    if let Some(pos) = pos {
-                        let idx = map.xy_idx(pos.x, pos.y);
-                        crate::spatial::remove_entity(entity, idx);
-                    }
-                }
-            }
-        }
-
-        if xp_gain != 0 {
-            let mut player_stats = stats.get_mut(*player).unwrap();
-            let player_attributes = attributes.get(*player).unwrap();
-            player_stats.xp += xp_gain;
-            let mut next_level_requirement = -1;
-            if player_stats.level < 10 {
-                next_level_requirement = 20 * 2_i32.pow(player_stats.level as u32 - 1);
-            } else if player_stats.level < 20 {
-                next_level_requirement = 10000 * 2_i32.pow(player_stats.level as u32 - 10);
-            } else if player_stats.level < 30 {
-                next_level_requirement = 10000000 * (player_stats.level - 19);
-            }
-            if next_level_requirement != -1 && player_stats.xp >= next_level_requirement {
-                // We've gone up a level!
-                player_stats.level += 1;
-                gamelog::record_event("player_level", 1);
-                gamelog::Logger::new()
-                    .append("Welcome to experience level")
-                    .append(player_stats.level)
-                    .append(".")
-                    .log();
-                for i in 0..5 {
-                    if player_pos.y - i > 1 {
-                        particle_builder.request(
-                            player_pos.x,
-                            player_pos.y - i,
-                            rltk::RGB::named(rltk::GOLD),
-                            rltk::RGB::named(rltk::BLACK),
-                            rltk::to_cp437('*'),
-                            200.0,
-                        );
-                    }
-                }
-                // Roll for HP gain this level
-                let hp_gained = hp_per_level(
-                    &mut rng,
-                    player_attributes.constitution.base + player_attributes.constitution.modifiers,
-                );
-                player_stats.hit_points.max += hp_gained;
-                player_stats.hit_points.current += hp_gained;
-                // Roll for MANA gain this level
-                let mana_gained = mana_per_level(
-                    &mut rng,
-                    player_attributes.intelligence.base + player_attributes.intelligence.modifiers,
-                );
-                player_stats.mana.max += mana_gained;
-                player_stats.mana.current += mana_gained;
-            }
-        }
-        // Clear the queue
-        damage.clear();
-    }
-}
-
 pub fn delete_the_dead(ecs: &mut World) {
     let mut dead: Vec<Entity> = Vec::new();
     // Using scope to make borrow checker happy

src/gamelog/logstore.rs

@@ -33,7 +33,11 @@ pub fn print_log(console: &mut Box<dyn Console>, pos: Point, _descending: bool,
         log.iter().for_each(|frag| {
             entry_len += frag.text.len() as i32;
         });
-        let lines = entry_len / maximum_len;
+        // I don't know why the +1 is required, or why there were issues on what seemed to be
+        // specified a value of 68. I'm pretty sure it's a ""rounding error"" between this method
+        // of determining max lines and how the iterator actually counts the characters. Regardless,
+        // this seems to work. -- NOTE IN CASE THIS ISSUE COMES BACK? HARD TO REPRODUCE!
+        let lines = entry_len / (maximum_len + 1);
         // If the fragment is more than one line long, move our y-value up
         // by this much.
         y -= lines;
@@ -47,6 +51,9 @@ pub fn print_log(console: &mut Box<dyn Console>, pos: Point, _descending: bool,
             // and reset our length counter to 0.
             for part in parts {
                 if len_so_far + part.len() as i32 > maximum_len {
+                    if y > pos.y - len as i32 {
+                        console.print(x, y, "-");
+                    }
                     y += 1;
                     x = pos.x;
                     len_so_far = 0;

src/main.rs

@@ -92,7 +92,6 @@ impl State {
         let mut vis = VisibilitySystem {};
         let mut trigger_system = trigger_system::TriggerSystem {};
         let mut melee_system = MeleeCombatSystem {};
-        let mut damage_system = DamageSystem {};
         let mut inventory_system = inventory::ItemCollectionSystem {};
         let mut item_equip_system = inventory::ItemEquipSystem {};
         let mut item_use_system = inventory::ItemUseSystem {};
@@ -113,7 +112,6 @@ impl State {
         item_remove_system.run_now(&self.ecs);
         item_id_system.run_now(&self.ecs);
         melee_system.run_now(&self.ecs);
-        damage_system.run_now(&self.ecs);
         effects::run_effects_queue(&mut self.ecs);
         hunger_clock.run_now(&self.ecs);
         particle_system.run_now(&self.ecs);

src/spawner.rs

@@ -91,6 +91,13 @@ pub fn player(ecs: &mut World, player_x: i32, player_y: i32) -> Entity {
         raws::SpawnType::Carried { by: player },
         0,
     );
+    raws::spawn_named_entity(
+        &raws::RAWS.lock().unwrap(),
+        ecs,
+        "scroll_mass_confusion",
+        raws::SpawnType::Carried { by: player },
+        0,
+    );
 
     return player;
 }