Gaining experience points

Author: Tomasz Sterna

src/components.rs

@@ -54,19 +54,24 @@ pub struct WantsToMelee {
 #[derive(TypeUuid, Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[uuid = "56a6359c-d947-438a-a13f-dfe65174cb6d"]
 pub struct SufferDamage {
-    pub amount: Vec<i32>,
+    pub amount: Vec<(i32, bool)>,
 }
 
 impl SufferDamage {
-    pub fn new_damage(command_buffer: &CommandBuffer, victim: Entity, amount: i32) {
+    pub fn new_damage(
+        command_buffer: &CommandBuffer,
+        victim: Entity,
+        amount: i32,
+        from_player: bool,
+    ) {
         command_buffer.exec_mut(move |world| {
             let mut dmg = if let Some(suffering) = world.get_component::<SufferDamage>(victim) {
                 (*suffering).clone()
             } else {
                 SufferDamage { amount: Vec::new() }
             };
 
-            dmg.amount.push(amount);
+            dmg.amount.push((amount, from_player));
             world
                 .add_component(victim, dmg)
                 .expect("Unable to insert damage");

src/damage_system.rs

@@ -1,6 +1,6 @@
 use super::{
-    gamelog::GameLog, Equipped, InBackpack, LootTable, Map, Name, Player, Pools, Position,
-    RunState, SufferDamage,
+    gamelog::GameLog, mana_at_level, player_hp_at_level, Attributes, Equipped, InBackpack,
+    LootTable, Map, Name, Player, Pools, Position, RunState, SufferDamage,
 };
 use crate::prefabs::{get_item_drop, spawn_named_item, SpawnType, PREFABS};
 use legion::prelude::*;
@@ -11,21 +11,55 @@ pub fn build() -> Box<(dyn Schedulable + 'static)> {
         .write_component::<Pools>()
         .read_component::<Position>()
         .write_resource::<Map>()
-        .build(|command_buffer, world, map, query| unsafe {
-            for (entity, mut damage) in query.iter_entities_unchecked(world) {
-                if let Some(mut stats) = world.get_component_mut_unchecked::<Pools>(entity) {
-                    stats.hit_points.current -= damage.amount.iter().sum::<i32>();
-                }
+        .read_resource::<Entity>()
+        .read_component::<Attributes>()
+        .build(
+            |command_buffer, world, (map, player_entity), query| unsafe {
+                let mut xp_gain = 0;
+                for (entity, mut damage) in query.iter_entities_unchecked(world) {
+                    if let Some(mut stats) = world.get_component_mut_unchecked::<Pools>(entity) {
+                        for (dmg, from_player) in damage.amount.iter() {
+                            stats.hit_points.current -= dmg;
+
+                            if stats.hit_points.current < 1 && *from_player {
+                                xp_gain += stats.level * 100;
+                            }
+                        }
+
+                        if let Some(pos) = world.get_component::<Position>(entity) {
+                            let idx = map.xy_idx(pos.x, pos.y);
+                            map.bloodstains.insert(idx);
+                        }
+                    }
 
-                if let Some(pos) = world.get_component::<Position>(entity) {
-                    let idx = map.xy_idx(pos.x, pos.y);
-                    map.bloodstains.insert(idx);
+                    damage.amount.clear();
+                    command_buffer.remove_component::<SufferDamage>(entity);
                 }
 
-                damage.amount.clear();
-                command_buffer.remove_component::<SufferDamage>(entity);
-            }
-        })
+                if xp_gain != 0 {
+                    let player_attributes =
+                        *(world.get_component::<Attributes>(**player_entity).unwrap());
+                    let mut player_stats =
+                        world.get_component_mut::<Pools>(**player_entity).unwrap();
+                    player_stats.experience += xp_gain;
+                    if player_stats.experience >= player_stats.level * 1000 {
+                        // We've gone up a level!
+                        player_stats.level = player_stats.experience / 1000 + 1;
+                        player_stats.hit_points.max = player_hp_at_level(
+                            player_attributes.fitness.base + player_attributes.fitness.modifiers,
+                            player_stats.level,
+                        );
+                        player_stats.hit_points.current = player_stats.hit_points.max;
+                        player_stats.mana.max = mana_at_level(
+                            player_attributes.intelligence.base
+                                + player_attributes.intelligence.modifiers,
+                            player_stats.level,
+                        );
+                        player_stats.mana.current = player_stats.mana.max;
+                    }
+                }
+            },
+        )
 }
 
 pub fn delete_the_dead(world: &mut World, resources: &mut Resources) {

src/gui.rs

@@ -64,8 +64,10 @@ pub fn draw_ui(world: &World, resources: &Resources, ctx: &mut Rltk) {
         stats.hit_points.current, stats.hit_points.max
     );
     let mana = format!("Mana:   {}/{}", stats.mana.current, stats.mana.max);
+    let xp = format!("Level:  {}", stats.level);
     ctx.print_color(50, 1, white, black, &health);
     ctx.print_color(50, 2, white, black, &mana);
+    ctx.print_color(50, 3, white, black, &xp);
     ctx.draw_bar_horizontal(
         64,
         1,
@@ -84,6 +86,16 @@ pub fn draw_ui(world: &World, resources: &Resources, ctx: &mut Rltk) {
         RGB::named(rltk::BLUE),
         RGB::named(rltk::BLACK),
     );
+    let xp_level_start = (stats.level - 1) * 1000;
+    ctx.draw_bar_horizontal(
+        64,
+        3,
+        14,
+        stats.experience - xp_level_start,
+        1000,
+        RGB::named(rltk::GOLD),
+        RGB::named(rltk::BLACK),
+    );
 
     // Attributes
     let attr = world.get_component::<Attributes>(*player).unwrap();

src/hunger_system.rs

@@ -51,7 +51,7 @@ pub fn build() -> Box<(dyn Schedulable + 'static)> {
                                             .to_string(),
                                     );
                                     }
-                                    SufferDamage::new_damage(command_buffer, entity, 1);
+                                    SufferDamage::new_damage(command_buffer, entity, 1, false);
                                 }
                             }
                         }

src/inventory_system.rs

@@ -216,7 +216,7 @@ pub fn item_use() -> Box<(dyn Schedulable + 'static)> {
                         for (target_entity, target_name) in targets.iter() {
                             let target_entity = *target_entity;
                             let damage = damages.damage;
-                            SufferDamage::new_damage(command_buffer, target_entity, damage);
+                            SufferDamage::new_damage(command_buffer, target_entity, damage, true);
                             if let Some(pos) = world.get_component::<Position>(target_entity) {
                                 particle_builder.request(
                                     pos.x,

src/melee_combat_system.rs

@@ -19,10 +19,11 @@ pub fn build() -> Box<(dyn Schedulable + 'static)> {
         .write_resource::<GameLog>()
         .write_resource::<ParticleBuilder>()
         .write_resource::<RandomNumberGenerator>()
+        .read_resource::<Entity>()
         .build(
             |command_buffer,
              world,
-             (log, particle_builder, rng),
+             (log, particle_builder, rng, player_entity),
              (query, query_melee, query_defense)| {
                 for (entity, (wants_melee, attacker_attributes, attacker_skills, attacker_pools)) in
                     query.iter_entities(world)
@@ -158,7 +159,12 @@ pub fn build() -> Box<(dyn Schedulable + 'static)> {
                                             + skill_damage_bonus
                                             + weapon_damage_bonus,
                                     );
-                                    SufferDamage::new_damage(&command_buffer, target, damage);
+                                    SufferDamage::new_damage(
+                                        &command_buffer,
+                                        target,
+                                        damage,
+                                        entity == **player_entity,
+                                    );
                                     log.entries.push(format!(
                                         "{} hits {}, for {} hp.",
                                         &attacker_name, &target_name, damage

src/trigger_system.rs

@@ -40,7 +40,12 @@ pub fn build() -> Box<(dyn Schedulable + 'static)> {
                                         rltk::to_cp437('‼'),
                                         200.0,
                                     );
-                                    SufferDamage::new_damage(command_buffer, entity, damage.damage);
+                                    SufferDamage::new_damage(
+                                        command_buffer,
+                                        entity,
+                                        damage.damage,
+                                        false,
+                                    );
                                 }
 
                                 // If it is single activation, it needs to be removed