levels, and ui changes

src/damage_system.rs

@@ -1,26 +1,109 @@
-use super::{gamelog, Entities, Item, Map, Name, Player, Pools, Position, RunState, SufferDamage};
+use super::{
+    gamelog, Attributes, GrantsXP, Item, Map, Name, ParticleBuilder, Player, Pools, Position, RunState, SufferDamage,
+};
+use crate::gamesystem::{mana_per_level, player_hp_per_level};
 use specs::prelude::*;
 
 pub struct DamageSystem {}
 
 impl<'a> System<'a> for DamageSystem {
+    #[allow(clippy::type_complexity)]
     type SystemData = (
         WriteStorage<'a, Pools>,
         WriteStorage<'a, SufferDamage>,
-        WriteExpect<'a, Map>,
         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, mut map, positions, entities) = data;
+        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() {
-            stats.hit_points.current -= damage.amount.iter().sum::<i32>();
-            let pos = positions.get(entity);
-            if let Some(pos) = pos {
-                let idx = map.xy_idx(pos.x, pos.y);
-                map.bloodstains.insert(idx);
+            for dmg in damage.amount.iter() {
+                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 xp_gain != 0 {
+            let mut player_stats = stats.get_mut(*player).unwrap();
+            let player_attributes = attributes.get(*player).unwrap();
+            player_stats.xp += xp_gain;
+            rltk::console::log(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::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,
+                        );
+                    }
+                }
+                let hp_gained = player_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;
+
+                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;
             }
         }