feat: added armour passives

src/armour/mod.rs

@@ -1,27 +1,55 @@
+use std::collections::HashMap;
+
 use bevy_ecs::prelude::*;
-use proxisim_models::bundle::armour::{
-    ArmourBodyPart, ArmourBodyPartSlot, ArmourBodyParts, ArmourCoverage, ArmourValue, ArmourVec,
-    BodyPartCoverage, Immunities, Immunity, PlayerArmour,
+use proxisim_models::bundle::{
+    armour::{
+        ArmourBodyPart, ArmourBodyPartSlot, ArmourBodyParts, ArmourCoverage, ArmourValue,
+        ArmourVec, BodyPartCoverage, Immunities, Immunity, PlayerArmour,
+    },
+    bonus::{ArmourBonusType, DamageMitigationBonus},
+    stat::{
+        AdditiveBonus, ArmourBonusValue, Defence, Dexterity, MaxHealth, SimpleStatBonus,
+        SimpleStatEffective,
+    },
 };
 use strum::IntoEnumIterator;
 
 use crate::{
     Stages,
+    effect::Effects,
     player::status_effect::{
         ConcussionGrenade, FlashGrenade, PepperSpray, TearGas, TempDebuffImmunity,
     },
 };
 
-fn generate_body_parts(
+fn equip_armour(
     equip_q: Query<(Entity, &PlayerArmour)>,
-    armour_q: Query<(Entity, &ArmourCoverage, &ArmourValue, Option<&Immunities>)>,
+    armour_q: Query<(
+        Entity,
+        &ArmourCoverage,
+        &ArmourValue,
+        Option<&Immunities>,
+        Option<&ArmourBonusType>,
+    )>,
     mut commands: Commands,
+    mut effects: Effects,
 ) {
     for (player, equipped_armour) in equip_q.iter() {
         let mut parts = ArmourVec::<ArmourBodyPart>::default();
 
-        for (armour, coverage, armour_value, immunities) in armour_q.iter_many(equipped_armour) {
-            // commands.entity(player).add_child(armour);
+        let mut set = Some(None);
+
+        for (armour, coverage, armour_value, immunities, bonus) in
+            armour_q.iter_many(equipped_armour)
+        {
+            if let Some(kind) = &mut set
+                && let Some(bonus) = bonus
+                && kind.is_none_or(|k| k == *bonus)
+            {
+                set = Some(Some(*bonus));
+            } else {
+                set = None
+            }
 
             if let Some(immunities) = immunities {
                 let mut player = commands.entity(player);
@@ -62,6 +90,28 @@ fn generate_body_parts(
             }
         }
 
+        if let Some(Some(set)) = set {
+            for piece in equipped_armour {
+                effects.spawn(
+                    SimpleStatBonus::<ArmourBonusValue>::new(
+                        "set bonus",
+                        match set {
+                            ArmourBonusType::Impregnable => 10,
+                            ArmourBonusType::Impenetrable => 10,
+                            ArmourBonusType::Insurmountable => 15,
+                            ArmourBonusType::Invulnerable => 15,
+                            ArmourBonusType::Imperviable => 1,
+                            ArmourBonusType::Immmutable => 5,
+                            ArmourBonusType::Irrepressible => 5,
+                            ArmourBonusType::Impassable => 10,
+                            ArmourBonusType::Kinetokinesis => 0,
+                        },
+                    ),
+                    piece,
+                );
+            }
+        }
+
         let parts = parts.0.map(|p| commands.spawn(p).id());
 
         commands
@@ -71,6 +121,82 @@ fn generate_body_parts(
     }
 }
 
-pub(crate) fn configure(stages: &mut Stages) {
-    stages.equip.add_systems(generate_body_parts);
+fn apply_passives(
+    bonus_q: Query<(
+        Entity,
+        &ArmourBonusType,
+        &SimpleStatEffective<ArmourBonusValue>,
+        &ChildOf,
+    )>,
+    mut effects: Effects,
+    mut commands: Commands,
+) {
+    let mut max_health_increase = HashMap::<Entity, u16>::new();
+    for (armour, kind, value, relation) in bonus_q {
+        match kind {
+            ArmourBonusType::Imperviable => {
+                *max_health_increase.entry(relation.parent()).or_default() += value.value;
+            }
+            ArmourBonusType::Immmutable => {
+                effects.spawn(
+                    AdditiveBonus::<Defence>::new("immutable", value.value as f32 / 100.0),
+                    relation.parent(),
+                );
+            }
+            ArmourBonusType::Irrepressible => {
+                effects.spawn(
+                    AdditiveBonus::<Dexterity>::new("irrepressible", value.value as f32 / 100.0),
+                    relation.parent(),
+                );
+            }
+            ArmourBonusType::Impregnable => {
+                commands
+                    .entity(armour)
+                    .insert(DamageMitigationBonus::Impregnable {
+                        mitigation: value.value as f32 / 100.0,
+                    });
+            }
+            ArmourBonusType::Impenetrable => {
+                commands
+                    .entity(armour)
+                    .insert(DamageMitigationBonus::Impenetrable {
+                        mitigation: value.value as f32 / 100.0,
+                    });
+            }
+            ArmourBonusType::Insurmountable => {
+                commands
+                    .entity(armour)
+                    .insert(DamageMitigationBonus::Insurmountable {
+                        mitigation: value.value as f32 / 100.0,
+                    });
+            }
+            ArmourBonusType::Impassable => {
+                commands
+                    .entity(armour)
+                    .insert(DamageMitigationBonus::Impassable {
+                        chance: value.value as f32 / 100.0,
+                    });
+            }
+            ArmourBonusType::Kinetokinesis => {
+                commands
+                    .entity(armour)
+                    .insert(DamageMitigationBonus::Kinetokinesis {
+                        mitigation: value.value as f32 / 100.0,
+                    });
+            }
+            _ => (),
+        }
+    }
+
+    for (target, increase) in max_health_increase {
+        effects.spawn(
+            SimpleStatBonus::<MaxHealth>::new("marauder", (increase as f32) * 0.01 + 1.0),
+            target,
+        );
+    }
+}
+
+pub(crate) fn configure(stages: &mut Stages) {
+    stages.equip.add_systems(equip_armour);
+    stages.passives.add_systems(apply_passives);
 }