exercising/abusing attributes

src/components.rs

@@ -258,6 +258,16 @@ pub struct Attribute {
     pub base: i32,
     pub modifiers: i32,
     pub bonus: i32,
+    pub exercise: i32,
+}
+
+impl Attribute {
+    pub fn improve(&mut self) {
+        self.exercise += 1;
+    }
+    pub fn abuse(&mut self) {
+        self.exercise -= 1;
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq, Hash)]
@@ -289,7 +299,6 @@ pub struct GrantsSpell {
 }
 
 // TODO: GrantsIntrinsic, Intrinsics, etc. ? Done the same way as spells?
-
 #[derive(Component, Debug, Serialize, Deserialize, Clone)]
 pub struct Attributes {
     pub strength: Attribute,
@@ -300,6 +309,65 @@ pub struct Attributes {
     pub charisma: Attribute,
 }
 
+impl Attributes {
+    pub const STR: i32 = 0;
+    pub const DEX: i32 = 1;
+    pub const CON: i32 = 2;
+    pub const INT: i32 = 3;
+    pub const WIS: i32 = 4;
+    pub const CHA: i32 = 5;
+    pub fn exercise(&mut self, attr: i32, improve: bool) {
+        match attr {
+            Self::STR => {
+                if improve {
+                    console::log("Improving strength.");
+                    console::log(format!("Value before: {}", self.strength.exercise));
+                    self.strength.improve();
+                    console::log(format!("Value after: {}", self.strength.exercise));
+                } else {
+                    self.strength.abuse();
+                }
+            }
+            Self::DEX => {
+                if improve {
+                    self.dexterity.improve();
+                } else {
+                    self.dexterity.abuse();
+                }
+            }
+            Self::CON => {
+                if improve {
+                    self.constitution.improve();
+                } else {
+                    self.constitution.abuse();
+                }
+            }
+            Self::INT => {
+                if improve {
+                    self.intelligence.improve();
+                } else {
+                    self.intelligence.abuse();
+                }
+            }
+            Self::WIS => {
+                if improve {
+                    self.wisdom.improve();
+                } else {
+                    self.wisdom.abuse();
+                }
+            }
+            Self::CHA => {
+                if improve {
+                    self.charisma.improve();
+                } else {
+                    self.charisma.abuse();
+                }
+            }
+            _ => unreachable!("Tried to exercise an attribute that doesn't exist."),
+        }
+    }
+}
+
 #[derive(Component, Debug, ConvertSaveload, Clone)]
 pub struct WantsToMelee {
     pub target: Entity,

src/effects/attr.rs

@@ -0,0 +1,18 @@
+use specs::prelude::*;
+use super::{ EffectSpawner, EffectType };
+use crate::components::Attributes;
+
+pub(crate) fn exercise(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
+    // Unwrap vars from the effect
+    let (attr, inc) = if let EffectType::Exercise { attribute, increment } = effect.effect_type {
+        (attribute, increment)
+    } else {
+        return;
+    };
+
+    // Get target attributes
+    let mut attributes = ecs.write_storage::<Attributes>();
+    if let Some(has_attr) = attributes.get_mut(target) {
+        has_attr.exercise(attr, inc);
+    }
+}

src/effects/mod.rs

@@ -11,6 +11,7 @@ mod hunger;
 mod particles;
 mod targeting;
 mod triggers;
+mod attr;
 
 pub use targeting::aoe_tiles;
 
@@ -31,6 +32,10 @@ pub enum EffectType {
         amount: i32,
         increment_max: bool,
     },
+    Exercise {
+        attribute: i32,
+        increment: bool,
+    },
     Confusion {
         turns: i32,
     },
@@ -162,6 +167,7 @@ fn affect_entity(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
     match &effect.effect_type {
         EffectType::Damage { .. } => damage::inflict_damage(ecs, effect, target),
         EffectType::Healing { .. } => damage::heal_damage(ecs, effect, target),
+        EffectType::Exercise { .. } => attr::exercise(ecs, effect, target),
         EffectType::Confusion { .. } => damage::add_confusion(ecs, effect, target),
         EffectType::Bloodstain { colour } => {
             if let Some(pos) = targeting::entity_position(ecs, target) {

src/gui/character_creation.rs

@@ -353,12 +353,37 @@ pub fn setup_player_class(ecs: &mut World, class: Class, ancestry: Ancestry) {
         let (str, dex, con, int, wis, cha) = get_attribute_rolls(&mut rng, class, ancestry);
         attributes
             .insert(player, Attributes {
-                strength: Attribute { base: str, modifiers: 0, bonus: attr_bonus(str) },
+                strength: Attribute {
-                dexterity: Attribute { base: dex, modifiers: 0, bonus: attr_bonus(dex) },
+                    base: str,
-                constitution: Attribute { base: con, modifiers: 0, bonus: attr_bonus(con) },
+                    modifiers: 0,
-                intelligence: Attribute { base: int, modifiers: 0, bonus: attr_bonus(int) },
+                    bonus: attr_bonus(str),
-                wisdom: Attribute { base: wis, modifiers: 0, bonus: attr_bonus(wis) },
+                    exercise: 0,
-                charisma: Attribute { base: cha, modifiers: 0, bonus: attr_bonus(cha) },
+                },
+                dexterity: Attribute {
+                    base: dex,
+                    modifiers: 0,
+                    bonus: attr_bonus(dex),
+                    exercise: 0,
+                },
+                constitution: Attribute {
+                    base: con,
+                    modifiers: 0,
+                    bonus: attr_bonus(con),
+                    exercise: 0,
+                },
+                intelligence: Attribute {
+                    base: int,
+                    modifiers: 0,
+                    bonus: attr_bonus(int),
+                    exercise: 0,
+                },
+                wisdom: Attribute { base: wis, modifiers: 0, bonus: attr_bonus(wis), exercise: 0 },
+                charisma: Attribute {
+                    base: cha,
+                    modifiers: 0,
+                    bonus: attr_bonus(cha),
+                    exercise: 0,
+                },
             })
             .expect("Unable to insert attributes component");
 

src/raws/rawmaster.rs

@@ -441,35 +441,65 @@ pub fn spawn_named_mob(
 
         // Setup combat stats
         let mut attr = Attributes {
-            strength: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            strength: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            dexterity: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            dexterity: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            constitution: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            constitution: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            intelligence: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            intelligence: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            wisdom: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            wisdom: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            charisma: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            charisma: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
         };
         let mut mob_con = 10;
         let mut mob_int = 10;
         if let Some(attributes) = &mob_template.attributes {
             if let Some(str) = attributes.str {
-                attr.strength = Attribute { base: str, modifiers: 0, bonus: attr_bonus(str) };
+                attr.strength = Attribute {
+                    base: str,
+                    modifiers: 0,
+                    bonus: attr_bonus(str),
+                    exercise: 0,
+                };
             }
             if let Some(dex) = attributes.dex {
-                attr.strength = Attribute { base: dex, modifiers: 0, bonus: attr_bonus(dex) };
+                attr.strength = Attribute {
+                    base: dex,
+                    modifiers: 0,
+                    bonus: attr_bonus(dex),
+                    exercise: 0,
+                };
             }
             if let Some(con) = attributes.con {
-                attr.constitution = Attribute { base: con, modifiers: 0, bonus: attr_bonus(con) };
+                attr.constitution = Attribute {
+                    base: con,
+                    modifiers: 0,
+                    bonus: attr_bonus(con),
+                    exercise: 0,
+                };
                 mob_con = con;
             }
             if let Some(int) = attributes.int {
-                attr.intelligence = Attribute { base: int, modifiers: 0, bonus: attr_bonus(int) };
+                attr.intelligence = Attribute {
+                    base: int,
+                    modifiers: 0,
+                    bonus: attr_bonus(int),
+                    exercise: 0,
+                };
                 mob_int = int;
             }
             if let Some(wis) = attributes.wis {
-                attr.wisdom = Attribute { base: wis, modifiers: 0, bonus: attr_bonus(wis) };
+                attr.wisdom = Attribute {
+                    base: wis,
+                    modifiers: 0,
+                    bonus: attr_bonus(wis),
+                    exercise: 0,
+                };
             }
             if let Some(cha) = attributes.cha {
-                attr.charisma = Attribute { base: cha, modifiers: 0, bonus: attr_bonus(cha) };
+                attr.charisma = Attribute {
+                    base: cha,
+                    modifiers: 0,
+                    bonus: attr_bonus(cha),
+                    exercise: 0,
+                };
             }
         }
         eb = eb.with(attr);

src/spawner.rs

@@ -79,12 +79,12 @@ pub fn player(ecs: &mut World, player_x: i32, player_y: i32) -> Entity {
         .with(HungerClock { state: HungerState::Satiated, duration: 1200 })
         .with(Attributes {
             // These are overwritten with chargen later -- placeholders.
-            strength: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            strength: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            dexterity: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            dexterity: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            constitution: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            constitution: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            intelligence: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            intelligence: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            wisdom: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            wisdom: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
-            charisma: Attribute { base: 10, modifiers: 0, bonus: 0 },
+            charisma: Attribute { base: 10, modifiers: 0, bonus: 0, exercise: 0 },
         })
         .with(Pools {
             // These are overwritten with chargen later -- placeholders.