rework again to skills with groupings

Author: dargem

cpp-backend-new/include/combatants/Combatant.hpp

@@ -16,7 +16,7 @@ class Combatant
     Combatant(int troops, Stats stats);
 
     [[nodiscard]] bool checkEffectActive(EffectType effect_type) const;
-    void addSkill(const Skill& skill, CombatantEvent combat_event);
+    void addSkill(const Skill* skill);
     void addStatusEffect(TimedEffect timed_effect, EffectType type);
 
     void setTroops(int troops);
@@ -25,7 +25,6 @@ class Combatant
     [[nodiscard]] double getAttack() const;
     [[nodiscard]] double getDefense() const;
     [[nodiscard]] double getHealth() const;
-
 private:
     int troops;
     Stats stats;

cpp-backend-new/include/orchestration/CombatPublisher.hpp

@@ -5,7 +5,7 @@
 #include <map>
 #include <memory>
 #include "orchestration/CombatantEvent.hpp"
-#include "skills/SkillGrouping.hpp"
+#include "skills/Skill.hpp"
 #include "utils/NumberGenerator.hpp"
 // forward declaration for combatant to avoid circular dependency
 class Combatant;
@@ -14,15 +14,14 @@ class CombatPublisher
 {
 public:
     CombatPublisher();
-    bool subToEvent(const SkillGrouping& skill_grouping);
-    bool unsubToEvent(const SkillGrouping& skill_grouping);
+    bool subToEvent(const Skill* skill);
+    bool unsubToEvent(const Skill* skill);
     void publishEvent(CombatantEvent event, Combatant& self, Combatant& target, NumberGenerator& number_generator) const;
 
-    // Takes ownership of the skill
-    void addSkillGrouping(std::unique_ptr<SkillGrouping> skill_grouping);
+    // Subscribe a skill reference (does not take ownership)
+    void addSkill(const Skill* skill);
 private:
-    std::vector<std::unique_ptr<const SkillGrouping>> owned_skill_groupings;
-    std::map<CombatantEvent, std::vector<const SkillGrouping&>> combat_event_subscribers;
+    std::map<CombatantEvent, std::vector<const Skill*>> combat_event_subscribers;
 };
 
 #endif

cpp-backend-new/include/orchestration/SetupPublisherLoader.hpp

@@ -24,19 +24,21 @@ class SetupPublisherLoader
     bool loadJson();
 
     /**
-     * @brief Loads a combat_publisher with 
+     * @brief Loads and owns all Skills from JSON, provides them to CombatPublishers via references
+     * Ownership of all Skills remains with SetupPublisherLoader
      * 
-     * @param combat_publisher 
-     * @param commanders 
+     * @param combat_publisher The publisher to subscribe skills to
+     * @param combatant_setup The setup containing commander information
      */
-    void loadPublisher(CombatPublisher& combat_publisher, const CombatantSetup& combatant_setup) const;
+    void loadPublisher(CombatPublisher& combat_publisher, const CombatantSetup& combatant_setup);
 private:
 
     static constexpr std::string_view skills_path = RESOURCE_DIR "/skills.json";
     json commander_data;
     json skill_data;
     json mount_slot_1_data;
     json mount_slot_2_data;
+    std::vector<std::unique_ptr<Skill>> owned_skills;
     /*
 
     std::vector<Skill> loadSkills(const json& skill_data, CommanderName commander_name, CombatPublisher& combat_publisher) const;

cpp-backend-new/include/skills/Skill.hpp

@@ -23,6 +23,10 @@ class Skill
         double chance
     );
 
+    Skill(
+        
+    );
+
     virtual ~Skill() = default;
 
     virtual void onDependent(
@@ -33,6 +37,8 @@ class Skill
 
     virtual bool operator==(const Skill& other) const = 0;
 
+    // Checks if a skill should trigger
+    // Checks RNG + Trigger condition
     [[nodiscard]] 
     bool checkCondition(
         const Combatant& friendly, 

cpp-backend-new/include/skills/SkillGrouping.hpp

@@ -7,10 +7,21 @@
 #include "utils/NumberGenerator.hpp"
 #include <memory>
 
-class SkillGrouping
+class SkillGrouping : Skill
 {
 public:
-    SkillGrouping(CombatantEvent dependent, double chance);
+    SkillGrouping(
+        SkillType skill_type, 
+        Condition skill_condition, 
+        CombatantEvent dependent, 
+        SkillTarget target,
+        double chance
+    );
+
+    SkillGrouping(
+        CombatantEvent dependent,
+        double chance
+    );
 
     /**
      * @brief Called when a dependent is triggered
@@ -23,25 +34,16 @@ class SkillGrouping
         Combatant& self, 
         Combatant& target, 
         NumberGenerator& number_generator
-    ) const;
+    ) const override;
 
     /**
      * @brief Add a skill to the groupings internal vector
      * 
      * @param skill skill to add
      */
     void addSkill(std::unique_ptr<Skill> skill);
-
-    [[nodiscard]] CombatantEvent getDependentEvent() const;
 private:
     std::vector<std::unique_ptr<Skill>> skills;
-
-    const CombatantEvent dependent;
-    const bool always_triggers;
-    const double chance;
-
-    [[nodiscard]] 
-    bool checkShouldTrigger(NumberGenerator& number_generator) const;
 };
 
 #endif

cpp-backend-new/src/combatants/Combatant.cpp

@@ -27,9 +27,9 @@ bool Combatant::checkEffectActive(const EffectType effect_type) const
     return status_controller.checkEffectActive(effect_type);
 }
 
-void Combatant::addSkill(const Skill& skill, const CombatantEvent combat_event)
+void Combatant::addSkill(const Skill* skill)
 {
-    combat_publisher.subToEvent(skill, combat_event);
+    combat_publisher.subToEvent(skill);
 }
 
 void Combatant::setTroops(int troops) 

cpp-backend-new/src/orchestration/CombatPublisher.cpp

@@ -7,31 +7,31 @@ CombatPublisher::CombatPublisher()
 {
     for (int i = 0; i < static_cast<int>(CombatantEvent::COUNT); ++i) 
     {
-        combat_event_subscribers[static_cast<CombatantEvent>(i)] = std::vector<const SkillGrouping&>();
+        combat_event_subscribers[static_cast<CombatantEvent>(i)] = std::vector<const Skill*>();
     }
 }
 
-bool CombatPublisher::subToEvent(const SkillGrouping& new_skill_grouping) 
+bool CombatPublisher::subToEvent(const Skill* skill) 
 {
-    CombatantEvent event = new_skill_grouping.getDependentEvent();
-    std::vector<const SkillGrouping&>& current_groupings = combat_event_subscribers[event];
+    CombatantEvent event = skill->getSkillDependent();
+    std::vector<const Skill*>& current_skills = combat_event_subscribers[event];
 
-    for (const SkillGrouping& skill_grouping : current_groupings)
+    for (const auto skill : current_skills)
     {
         // equivalence logic, return false if is in already
     }
 
-    current_groupings.push_back(new_skill_grouping);
+    current_skills.push_back(skill);
 
     return true;
 }
 
-bool CombatPublisher::unsubToEvent(const SkillGrouping& remove_skill_grouping)
+bool CombatPublisher::unsubToEvent(const Skill* skill)
 {
-    CombatantEvent event = remove_skill_grouping.getDependentEvent();
-    std::vector<const SkillGrouping&>& current_groupings = combat_event_subscribers[event];
+    CombatantEvent event = skill->getSkillDependent();
+    std::vector<const Skill*>& current_skills = combat_event_subscribers[event];
 
-    for (const SkillGrouping& skill_grouping : current_groupings)
+    for (const Skill* skill : current_skills)
     {
         // equivalent logic, erase and return true if already in
     }
@@ -42,14 +42,14 @@ bool CombatPublisher::unsubToEvent(const SkillGrouping& remove_skill_grouping)
 
 void CombatPublisher::publishEvent(const CombatantEvent event, Combatant& self, Combatant& target, NumberGenerator& number_generator) const
 {
-    const std::vector<const SkillGrouping&>& skills = combat_event_subscribers.at(event);
-    for (const Skill& skill : skills)
+    const std::vector<const Skill*>& skills = combat_event_subscribers.at(event);
+    for (const Skill* skill : skills)
     {
-        skill.onDependent(self, target, number_generator);
+        skill->onDependent(self, target, number_generator);
     }
 }
 
-void CombatPublisher::addSkillGrouping(std::unique_ptr<SkillGrouping> skill_grouping) 
+void CombatPublisher::addSkill(const Skill* skill) 
 {
-    owned_skill_groupings.push_back(std::move(skill_grouping));
-}
+    subToEvent(skill);
+}

cpp-backend-new/src/orchestration/SetupPublisherLoader.cpp

@@ -33,7 +33,7 @@ bool SetupPublisherLoader::loadJson()
     }
 }
 
-void SetupPublisherLoader::loadPublisher(CombatPublisher& combat_publisher, const CombatantSetup& combatant_setup) const
+void SetupPublisherLoader::loadPublisher(CombatPublisher& combat_publisher, const CombatantSetup& combatant_setup)
 {
     SkillParser parser;
 
@@ -45,7 +45,9 @@ void SetupPublisherLoader::loadPublisher(CombatPublisher& combat_publisher, cons
         auto skills = parser.loadSkills(skill_data, combatant_setup.commanders[i], is_primary);
         for (auto& skill : skills) 
         {
-            combat_publisher.addSkill(std::move(skill));
+            // Store ownership in this loader, provide reference to publisher
+            combat_publisher.addSkill(skill.get());
+            owned_skills.push_back(std::move(skill));
         }
     }
 

cpp-backend-new/src/skills/Skill.cpp

@@ -35,6 +35,7 @@ bool Skill::checkCondition(
     );
 }
 
+
 SkillTarget Skill::getSkillTarget() const
 {
     return target;

cpp-backend-new/src/skills/SkillGrouping.cpp

@@ -1,15 +1,19 @@
 #include "skills/SkillGrouping.hpp"
 
-SkillGrouping::SkillGrouping(CombatantEvent dependent, double chance)
-    : dependent { dependent },
-    chance { chance },
-    always_triggers { chance == 1.0 }
+SkillGrouping::SkillGrouping(
+    SkillType skill_type, 
+    Condition skill_condition, 
+    CombatantEvent dependent, 
+    SkillTarget target,
+    double chance
+)
+    : Skill(skill_type, skill_condition, dependent, target, chance)
 {}
 
 void SkillGrouping::onDependent(Combatant& self, Combatant& target, NumberGenerator& number_generator) const
 {
     // early return if shouldn't trigger
-    if (!checkShouldTrigger(number_generator))
+    if (!Skill::checkCondition(self, target, number_generator))
     {
         return;
     }
@@ -20,18 +24,7 @@ void SkillGrouping::onDependent(Combatant& self, Combatant& target, NumberGenera
     }
 }
 
-CombatantEvent SkillGrouping::getDependentEvent() const
-{
-    return dependent;
-}
-
 void SkillGrouping::addSkill(std::unique_ptr<Skill> skill)
 {
     skills.push_back(std::move(skill));
 }
-
-inline bool SkillGrouping::checkShouldTrigger(NumberGenerator& number_generator) const
-{
-    return always_triggers || number_generator.getRandomDouble() < chance;
-}
-