From 80f2a20c3539ceeca7e5fda8aadce0513427bfc0 Mon Sep 17 00:00:00 2001
From: Sam <samuelkeiffer@gmail.com>
Date: Wed, 18 Nov 2020 19:26:55 -0600
Subject: [PATCH] Skills can now have prerequisite skills. Skills can now cost
 different amounts of skill points.

---
 client/src/lib.rs         | 10 ++++++++
 common/src/comp/skills.rs | 53 +++++++++++++++++++++++++++++++++------
 2 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/client/src/lib.rs b/client/src/lib.rs
index 1331838ab5..c762dddadf 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -982,6 +982,16 @@ impl Client {
                                 SkillGroupType::Weapon(Sceptre),
                             )));
                         },
+                        "@unlock health1" => {
+                            self.send_msg(ClientGeneral::UnlockSkill(Skill::General(
+                                GeneralSkill::HealthIncrease1,
+                            )));
+                        },
+                        "@unlock health2" => {
+                            self.send_msg(ClientGeneral::UnlockSkill(Skill::General(
+                                GeneralSkill::HealthIncrease2,
+                            )));
+                        },
                         _ => {},
                     }
                 } else {
diff --git a/common/src/comp/skills.rs b/common/src/comp/skills.rs
index 720572b176..2ad19b15a6 100644
--- a/common/src/comp/skills.rs
+++ b/common/src/comp/skills.rs
@@ -192,19 +192,24 @@ impl SkillSet {
     pub fn unlock_skill(&mut self, skill: Skill) {
         if !self.skills.contains(&skill) {
             if let Some(skill_group_type) = SkillSet::get_skill_group_type_for_skill(&skill) {
+                let prerequisites_met = self.prerequisites_met(skill);
                 if let Some(mut skill_group) = self
                     .skill_groups
                     .iter_mut()
                     .find(|x| x.skill_group_type == skill_group_type)
                 {
-                    if skill_group.available_sp > 0 {
-                        skill_group.available_sp -= 1;
-                        if let Skill::UnlockGroup(group) = skill {
-                            self.unlock_skill_group(group);
+                    if prerequisites_met {
+                        if skill_group.available_sp >= skill.skill_cost() {
+                            skill_group.available_sp -= skill.skill_cost();
+                            if let Skill::UnlockGroup(group) = skill {
+                                self.unlock_skill_group(group);
+                            }
+                            self.skills.insert(skill);
+                        } else {
+                            warn!("Tried to unlock skill for skill group with insufficient SP");
                         }
-                        self.skills.insert(skill);
                     } else {
-                        warn!("Tried to unlock skill for skill group with no available SP");
+                        warn!("Tried to unlock skill without meeting prerequisite skills");
                     }
                 } else {
                     warn!("Tried to unlock skill for a skill group that player does not have");
@@ -243,7 +248,7 @@ impl SkillSet {
                     .iter_mut()
                     .find(|x| x.skill_group_type == skill_group_type)
                 {
-                    skill_group.available_sp += 1;
+                    skill_group.available_sp += skill.skill_cost();
                     self.skills.remove(&skill);
                 } else {
                     warn!("Tried to refund skill for a skill group that player does not have");
@@ -320,6 +325,40 @@ impl SkillSet {
             warn!("Tried to add experience to a skill group that player does not have");
         }
     }
+
+    /// Checks that the skill set contains all prerequisite skills for a
+    /// particular skill
+    pub fn prerequisites_met(&self, skill: Skill) -> bool {
+        skill
+            .prerequisite_skills()
+            .iter()
+            .all(|s| self.skills.contains(s))
+    }
+}
+
+impl Skill {
+    /// Returns a vec of prerequisite skills (it should only be necessary to
+    /// note direct prerequisites)
+    pub fn prerequisite_skills(self) -> Vec<Skill> {
+        let mut prerequisites = Vec::new();
+        use Skill::*;
+        match self {
+            General(GeneralSkill::HealthIncrease2) => {
+                prerequisites.push(General(GeneralSkill::HealthIncrease1));
+            },
+            _ => {},
+        }
+        prerequisites
+    }
+
+    /// Returns the cost in skill points of unlocking a particular skill
+    pub fn skill_cost(self) -> u16 {
+        use Skill::*;
+        match self {
+            General(GeneralSkill::HealthIncrease2) => 2,
+            _ => 1,
+        }
+    }
 }
 
 #[cfg(test)]