Check for prerequisite skill in using an ability is no longer hardcoded.

assets/common/abilities/weapon_ability_manifest.ron

@@ -5,35 +5,35 @@
         primary: "common.abilities.sword.triplestrike",
         secondary: "common.abilities.sword.dash",
         skills: [
-            "common.abilities.sword.spin",
+            (Some(Sword(UnlockSpin)), "common.abilities.sword.spin"),
         ],
     ),
     Axe: (
         primary: "common.abilities.axe.doublestrike",
         secondary: "common.abilities.axe.spin",
         skills: [
-            "common.abilities.axe.leap",
+            (Some(Axe(UnlockLeap)), "common.abilities.axe.leap"),
         ],
     ),
     Hammer: (
         primary: "common.abilities.hammer.singlestrike",
         secondary: "common.abilities.hammer.charged",
         skills: [
-            "common.abilities.hammer.leap",
+            (Some(Hammer(UnlockLeap)), "common.abilities.hammer.leap"),
         ],
     ),
     Bow: (
         primary: "common.abilities.bow.basic",
         secondary: "common.abilities.bow.charged",
         skills: [
-            "common.abilities.bow.repeater",
+            (Some(Bow(UnlockRepeater)), "common.abilities.bow.repeater"),
         ],
     ),
     Staff: (
         primary: "common.abilities.staff.firebomb",
         secondary: "common.abilities.staff.flamethrower",
         skills: [
-            "common.abilities.staff.fireshockwave",
+            (Some(Staff(UnlockShockwave)), "common.abilities.staff.fireshockwave"),
         ],
     ),
     Sceptre: (
@@ -55,7 +55,7 @@
         primary: "common.abilities.unique.stonegolemfist.basic",
         secondary: "common.abilities.unique.stonegolemfist.shockwave",
         skills: [
-            "common.abilities.unique.stonegolemfist.spin",
+            (None, "common.abilities.unique.stonegolemfist.spin"),
         ],
     ),
     Unique(BeastClaws): (
@@ -72,7 +72,7 @@
         primary: "common.abilities.unique.quadmedjump.leap",
         secondary: "common.abilities.unique.quadmedjump.doublestrike",
         skills: [
-            "common.abilities.unique.quadmedjump.quickleap"
+            (None, "common.abilities.unique.quadmedjump.quickleap"),
         ],
     ),
     Unique(QuadMedCharge): (
@@ -99,7 +99,7 @@
         primary: "common.abilities.unique.quadlowbreathe.flamethrower",
         secondary: "common.abilities.unique.quadlowbreathe.triplestrike",
         skills: [
-            "common.abilities.unique.quadlowbreathe.dash",
+            (None, "common.abilities.unique.quadlowbreathe.dash"),
         ],
     ),
     Unique(QuadLowTail): (
@@ -136,7 +136,7 @@
         primary: "common.abilities.debug.forwardboost",
         secondary: "common.abilities.debug.upboost",
         skills: [
-            "common.abilities.debug.possess",
+            (None, "common.abilities.debug.possess"),
         ],
     ),
     Farming: (

common/src/comp/inventory/item/mod.rs

@@ -8,6 +8,7 @@ use crate::{
     assets::{self, AssetExt, Error},
     comp::{
         inventory::{item::tool::AbilityMap, InvSlot},
+        skills::Skill,
         Body, CharacterAbility,
     },
     effect::Effect,
@@ -187,7 +188,7 @@ impl PartialEq for ItemDef {
 pub struct ItemConfig {
     pub ability1: Option<CharacterAbility>,
     pub ability2: Option<CharacterAbility>,
-    pub ability3: Option<CharacterAbility>,
+    pub ability3: Option<(Option<Skill>, CharacterAbility)>,
     pub block_ability: Option<CharacterAbility>,
     pub dodge_ability: Option<CharacterAbility>,
 }

common/src/comp/inventory/item/tool.rs

@@ -3,7 +3,7 @@
 
 use crate::{
     assets::{self, Asset},
-    comp::CharacterAbility,
+    comp::{skills::Skill, CharacterAbility},
 };
 use hashbrown::HashMap;
 use serde::{Deserialize, Serialize};
@@ -113,7 +113,7 @@ impl Tool {
 pub struct AbilitySet<T> {
     pub primary: T,
     pub secondary: T,
-    pub skills: Vec<T>,
+    pub skills: Vec<(Option<Skill>, T)>,
 }
 
 impl AbilitySet<CharacterAbility> {
@@ -133,7 +133,7 @@ impl<T> AbilitySet<T> {
         AbilitySet {
             primary: f(self.primary),
             secondary: f(self.secondary),
-            skills: self.skills.into_iter().map(|x| f(x)).collect(),
+            skills: self.skills.into_iter().map(|(s, x)| (s, f(x))).collect(),
         }
     }
 
@@ -141,7 +141,7 @@ impl<T> AbilitySet<T> {
         AbilitySet {
             primary: f(&self.primary),
             secondary: f(&self.secondary),
-            skills: self.skills.iter().map(|x| f(x)).collect(),
+            skills: self.skills.iter().map(|(s, x)| (*s, f(x))).collect(),
         }
     }
 }

common/src/states/utils.rs

@@ -1,10 +1,8 @@
 use crate::{
     comp::{
         inventory::slot::EquipSlot,
-        item::{Hands, ItemKind, Tool, ToolKind},
+        item::{Hands, ItemKind, Tool},
-        quadruped_low, quadruped_medium,
+        quadruped_low, quadruped_medium, theropod, Body, CharacterState, LoadoutManip, StateUpdate,
-        skills::{AxeSkill, BowSkill, HammerSkill, Skill, StaffSkill, SwordSkill},
-        theropod, Body, CharacterState, LoadoutManip, StateUpdate,
     },
     consts::{FRIC_GROUND, GRAVITY},
     event::{LocalEvent, ServerEvent},
@@ -497,49 +495,9 @@ pub fn handle_ability3_input(data: &JoinData, update: &mut StateUpdate) {
                 i.item_config_expect()
                     .ability3
                     .as_ref()
-                    .and_then(|s| match tool {
+                    .and_then(|(s, a)| {
-                        // TODO: Make this so abilities aren't hardcoded to ability3
+                        s.map_or(true, |s| data.stats.skill_set.has_skill(s))
-                        Some(ToolKind::Sword)
+                            .then_some(a)
-                            if !&data
-                                .stats
-                                .skill_set
-                                .has_skill(Skill::Sword(SwordSkill::UnlockSpin)) =>
-                        {
-                            None
-                        },
-                        Some(ToolKind::Axe)
-                            if !&data
-                                .stats
-                                .skill_set
-                                .has_skill(Skill::Axe(AxeSkill::UnlockLeap)) =>
-                        {
-                            None
-                        },
-                        Some(ToolKind::Hammer)
-                            if !&data
-                                .stats
-                                .skill_set
-                                .has_skill(Skill::Hammer(HammerSkill::UnlockLeap)) =>
-                        {
-                            None
-                        },
-                        Some(ToolKind::Bow)
-                            if !&data
-                                .stats
-                                .skill_set
-                                .has_skill(Skill::Bow(BowSkill::UnlockRepeater)) =>
-                        {
-                            None
-                        },
-                        Some(ToolKind::Staff)
-                            if !&data
-                                .stats
-                                .skill_set
-                                .has_skill(Skill::Staff(StaffSkill::UnlockShockwave)) =>
-                        {
-                            None
-                        },
-                        _ => Some(s),
                     })
                     .map(|a| a.clone().adjusted_by_skills(&data.stats.skill_set, tool))
             })

voxygen/src/hud/hotbar.rs

@@ -74,44 +74,14 @@ impl State {
         let stats = client.state().ecs().read_storage::<common::comp::Stats>();
         let stat = stats.get(client.entity());
         let should_be_present = if let (Some(inventory), Some(stat)) = (inventory, stat) {
-            inventory
+            inventory.equipped(EquipSlot::Mainhand).map_or(false, |i| {
-                .equipped(EquipSlot::Mainhand)
+                i.item_config_expect()
-                .map(|i| i.kind())
+                    .ability3
-                .filter(|kind| {
+                    .as_ref()
-                    use common::comp::{
+                    .map_or(false, |(s, _)| {
-                        item::{
+                        s.map_or(true, |s| stat.skill_set.has_skill(s))
-                            tool::{ToolKind, UniqueKind},
+                    })
-                            ItemKind,
+            })
-                        },
-                        skills::{self, Skill},
-                    };
-                    if let ItemKind::Tool(tool) = kind {
-                        match tool.kind {
-                            ToolKind::Sword => stat
-                                .skill_set
-                                .has_skill(Skill::Sword(skills::SwordSkill::UnlockSpin)),
-                            ToolKind::Axe => stat
-                                .skill_set
-                                .has_skill(Skill::Axe(skills::AxeSkill::UnlockLeap)),
-                            ToolKind::Hammer => stat
-                                .skill_set
-                                .has_skill(Skill::Hammer(skills::HammerSkill::UnlockLeap)),
-                            ToolKind::Bow => stat
-                                .skill_set
-                                .has_skill(Skill::Bow(skills::BowSkill::UnlockRepeater)),
-                            ToolKind::Staff => stat
-                                .skill_set
-                                .has_skill(Skill::Staff(skills::StaffSkill::UnlockShockwave)),
-                            ToolKind::Debug
-                            | ToolKind::Unique(UniqueKind::QuadMedQuick)
-                            | ToolKind::Unique(UniqueKind::QuadLowBreathe) => true,
-                            _ => false,
-                        }
-                    } else {
-                        false
-                    }
-                })
-                .is_some()
         } else {
             false
         };

voxygen/src/hud/slots.rs

@@ -136,7 +136,7 @@ impl<'a> SlotKey<HotbarSource<'a>, HotbarImageSource<'a>> for HotbarSlot {
                         (
                             i,
                             if let Some(skill) = tool.get_abilities(ability_map).skills.get(0) {
-                                if energy.current() >= skill.get_energy_cost() {
+                                if energy.current() >= skill.1.get_energy_cost() {
                                     Some(Color::Rgba(1.0, 1.0, 1.0, 1.0))
                                 } else {
                                     Some(Color::Rgba(0.3, 0.3, 0.3, 0.8))