Support for ending battles when only one side has creatures that are available for battle.

src/Battling/Library/BattleStatCalculator.cpp

@@ -26,14 +26,14 @@ uint32_t CalculateHealthStat(Battling::Creature* creature) {
     auto level = creature->GetLevel();
     auto a =
         (creature->GetBaseStat(Core::Statistic::Health) + creature->GetStatPotential(Core::Statistic::Health)) * 2 +
-        floor(sqrt(creature->GetStatExperience(Core::Statistic::Health) / 4)) * level;
+        floor(sqrt(creature->GetStatExperience(Core::Statistic::Health) / 4.0)) * level;
     return floor(a / 100) + level + 10;
 }
 
 uint32_t CalculateOtherStat(Battling::Creature* creature, Core::Statistic stat) {
     auto level = creature->GetLevel();
     auto a = (creature->GetBaseStat(stat) + creature->GetStatPotential(stat)) * 2 +
-             floor(sqrt(creature->GetStatExperience(stat) / 4)) * level;
+             floor(sqrt(creature->GetStatExperience(stat) / 4.0)) * level;
     return floor(a / 100) + 10;
 }
 

src/Battling/Models/Battle.cpp

@@ -97,3 +97,20 @@ bool Battle::CanSlotBeFilled(uint8_t side, uint8_t index) const {
     }
     return false;
 }
+
+void Battle::ValidateBattleState() {
+    bool survivingSideExists = false;
+    uint8_t result = 0;
+    for (uint8_t i = 0; i < _sides.size(); i++){
+        auto side = _sides[i];
+        if (!side->IsDefeated()){
+            if (survivingSideExists){
+                return;
+            }
+            survivingSideExists = true;
+            result = i;
+        }
+    }
+    this->_battleResult = result;
+    this->_hasEnded = true;
+}

src/Battling/Models/Battle.hpp

@@ -18,6 +18,8 @@ namespace CreatureLib::Battling {
         std::vector<BattleSide*> _sides;
         Core::Random _random;
         ChoiceQueue* _currentTurnQueue = nullptr;
+        bool _hasEnded = false;
+        uint8_t _battleResult = 0;
 
         ScriptSet _volatile;
 
@@ -58,6 +60,10 @@ namespace CreatureLib::Battling {
         bool CanSlotBeFilled(uint8_t side, uint8_t index) const;
 
         void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override;
+
+        void ValidateBattleState();
+        inline bool HasEnded() const { return _hasEnded; }
+        inline uint8_t GetResult() const { return _battleResult; }
     };
 }
 

src/Battling/Models/BattleSide.cpp

@@ -37,8 +37,13 @@ void BattleSide::SetChoice(BaseTurnChoice* choice) {
 }
 
 void BattleSide::SetCreature(Creature* creature, uint8_t index) {
+    auto old = _creatures[index];
+    if (old != nullptr){
+        old->SetOnBattleField(false);
+    }
     _creatures[index] = creature;
     creature->SetBattleData(_battle, this);
+    creature->SetOnBattleField(true);
 }
 
 bool BattleSide::CreatureOnSide(const Creature* creature) const {

src/Battling/Models/BattleSide.hpp

@@ -11,6 +11,7 @@ namespace CreatureLib::Battling {
         uint8_t _creaturesPerSide;
         std::vector<Creature*> _creatures;
         std::vector<BaseTurnChoice*> _choices;
+        std::vector<bool> _fillableSlots;
         uint8_t _choicesSet = 0;
         ScriptSet _volatile;
         Battle* _battle;
@@ -20,9 +21,11 @@ namespace CreatureLib::Battling {
             : _index(index), _creaturesPerSide(creaturesPerSide), _battle(battle) {
             _creatures = std::vector<Creature*>(creaturesPerSide);
             _choices = std::vector<BaseTurnChoice*>(creaturesPerSide);
+            _fillableSlots = std::vector<bool>(creaturesPerSide);
             for (size_t i = 0; i < creaturesPerSide; i++) {
                 _creatures[i] = nullptr;
                 _choices[i] = nullptr;
+                _fillableSlots[i] = true;
             }
             ResetChoices();
         }
@@ -43,6 +46,22 @@ namespace CreatureLib::Battling {
         bool CreatureOnSide(const Creature* creature) const;
 
         void GetActiveScripts(std::vector<ScriptWrapper>& scripts) final;
+
+        void MarkSlotAsUnfillable(Creature* creature){
+            for (uint8_t i = 0; i < _creaturesPerSide; i++){
+                if (_creatures[i] == creature){
+                    _fillableSlots[i] = false;
+                    return;
+                }
+            }
+        }
+
+        bool IsDefeated(){
+            for (auto b: _fillableSlots){
+                if (b) return false;
+            }
+            return true;
+        }
     };
 }
 

src/Battling/Models/Creature.cpp

@@ -98,6 +98,11 @@ void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source)
     }
     // HOOK: On Damage
     __CurrentHealth -= damage;
+
+    if (IsFainted()){
+        _side->MarkSlotAsUnfillable(this);
+        _battle->ValidateBattleState();
+    }
 }
 
 void Battling::Creature::OverrideActiveTalent(const std::string& talent) {

src/Battling/Models/Creature.hpp

@@ -69,6 +69,7 @@ namespace CreatureLib::Battling {
         void SetBattleData(Battle* battle, BattleSide* side);
         Battle* GetBattle() const;
         BattleSide* GetBattleSide() const;
+        void SetOnBattleField(bool value) {_onBattleField = value;}
         bool IsOnBattleField() const { return _onBattleField; }
 
         const std::string& GetNickname() const;