Finished section 1

src/inventory_system.rs

@@ -2,14 +2,15 @@ use specs::prelude::*;
 
 use crate::gamelog::GameLog;
 use crate::{
-    AreaOfEffect, CombatStats, Confusion, Consumable, InBackpack, InflictsDamage, Map, Name,
-    Position, ProvidesHealing, Ranged, SufferDamage, WantsToDropItem, WantsToPickupItem,
-    WantsToUseItem,
+    AreaOfEffect, CombatStats, Confusion, Consumable, Equippable, Equipped, InBackpack,
+    InflictsDamage, Map, Name, Position, ProvidesHealing, Ranged, SufferDamage, WantsToDropItem,
+    WantsToPickupItem, WantsToRemoveItem, WantsToUseItem,
 };
 
 pub struct ItemCollectionSystem {}
 
 impl<'a> System<'a> for ItemCollectionSystem {
+    #[allow(clippy::complexity)]
     type SystemData = (
         ReadExpect<'a, Entity>,
         WriteExpect<'a, GameLog>,
@@ -49,6 +50,7 @@ impl<'a> System<'a> for ItemCollectionSystem {
 pub struct ItemUseSystem {}
 
 impl<'a> System<'a> for ItemUseSystem {
+    #[allow(clippy::complexity)]
     type SystemData = (
         ReadExpect<'a, Entity>,
         WriteExpect<'a, GameLog>,
@@ -64,6 +66,9 @@ impl<'a> System<'a> for ItemUseSystem {
         WriteStorage<'a, SufferDamage>,
         ReadStorage<'a, AreaOfEffect>,
         WriteStorage<'a, Confusion>,
+        ReadStorage<'a, Equippable>,
+        WriteStorage<'a, Equipped>,
+        WriteStorage<'a, InBackpack>,
     );
 
     fn run(&mut self, data: Self::SystemData) {
@@ -82,6 +87,9 @@ impl<'a> System<'a> for ItemUseSystem {
             mut suffer_damage,
             aoe,
             mut confused,
+            equippable,
+            mut equipped,
+            mut backpack,
         ) = data;
 
         for (entity, use_item) in (&entities, &wants_use).join() {
@@ -116,6 +124,43 @@ impl<'a> System<'a> for ItemUseSystem {
                 }
             }
 
+            if let Some(item_equippable) = equippable.get(use_item.item) {
+                let target_slot = item_equippable.slot;
+                let target = targets[0];
+                let mut to_unequip: Vec<Entity> = Vec::new();
+                for (item_entity, already_equipped, name) in (&entities, &equipped, &names).join() {
+                    if already_equipped.owner == target && already_equipped.slot == target_slot {
+                        to_unequip.push(item_entity);
+                        if target == *player_entity {
+                            game_log.entries.push(format!("You unequip {}.", name.name));
+                        }
+                    }
+                }
+                for item in to_unequip.iter() {
+                    equipped.remove(*item);
+                    backpack
+                        .insert(*item, InBackpack { owner: target })
+                        .expect("Unable to insert item into backpack");
+                }
+
+                equipped
+                    .insert(
+                        use_item.item,
+                        Equipped {
+                            owner: target,
+                            slot: target_slot,
+                        },
+                    )
+                    .expect("Unable to equip item");
+                backpack.remove(use_item.item);
+                if target == *player_entity {
+                    game_log.entries.push(format!(
+                        "You equip item {}.",
+                        names.get(use_item.item).unwrap().name
+                    ))
+                }
+            }
+
             if let Some(item_damages) = inflicts_damage.get(use_item.item) {
                 used_item = false;
                 for mob in targets.iter() {
@@ -242,3 +287,26 @@ impl<'a> System<'a> for ItemDropSystem {
         wants_drop.clear();
     }
 }
+
+pub struct ItemRemoveSystem {}
+
+impl<'a> System<'a> for ItemRemoveSystem {
+    type SystemData = (
+        Entities<'a>,
+        WriteStorage<'a, WantsToRemoveItem>,
+        WriteStorage<'a, Equipped>,
+        WriteStorage<'a, InBackpack>,
+    );
+
+    fn run(&mut self, data: Self::SystemData) {
+        let (entities, mut wants_to_remove_item, mut equipped, mut backpack) = data;
+        for (entity, to_remove) in (&entities, &wants_to_remove_item).join() {
+            equipped.remove(to_remove.item);
+            backpack
+                .insert(to_remove.item, InBackpack { owner: entity })
+                .expect("Unable to insert item into backpack");
+        }
+
+        wants_to_remove_item.clear();
+    }
+}