Implements running from battle.

src/Battling/Models/Battle.cpp

@@ -100,17 +100,22 @@ bool Battle::CanSlotBeFilled(uint8_t side, uint8_t index) const {
 
 void Battle::ValidateBattleState() {
     bool survivingSideExists = false;
-    uint8_t result = 0;
-    for (uint8_t i = 0; i < _sides.size(); i++){
+    uint8_t winningSide = 0;
+    for (uint8_t i = 0; i < _sides.size(); i++) {
         auto side = _sides[i];
-        if (!side->IsDefeated()){
-            if (survivingSideExists){
+        if (side->HasFled()) {
+            this->_battleResult = BattleResult::Inconclusive();
+            this->_hasEnded = true;
+            return;
+        }
+        if (!side->IsDefeated()) {
+            if (survivingSideExists) {
                 return;
             }
             survivingSideExists = true;
-            result = i;
+            winningSide = i;
         }
     }
-    this->_battleResult = result;
+    this->_battleResult = BattleResult::Conclusive(winningSide);
     this->_hasEnded = true;
 }

src/Battling/Models/Battle.hpp

@@ -6,6 +6,7 @@
 #include "../Library/BattleLibrary.hpp"
 #include "../TurnChoices/BaseTurnChoice.hpp"
 #include "BattleParty.hpp"
+#include "BattleResult.hpp"
 #include "BattleSide.hpp"
 #include "CreatureIndex.hpp"
 
@@ -13,20 +14,22 @@ namespace CreatureLib::Battling {
     class Battle : public ScriptSource {
         const BattleLibrary* _library;
         std::vector<BattleParty> _parties;
+        bool _canFlee;
         uint8_t _numberOfSides;
         uint8_t _creaturesPerSide;
         std::vector<BattleSide*> _sides;
         Core::Random _random;
         ChoiceQueue* _currentTurnQueue = nullptr;
         bool _hasEnded = false;
-        uint8_t _battleResult = 0;
+        BattleResult _battleResult = BattleResult::Empty();
 
         ScriptSet _volatile;
 
     public:
-        Battle(const BattleLibrary* library, std::vector<BattleParty> parties, uint8_t numberOfSides = 2,
-               uint8_t creaturesPerSide = 1)
-            : _library(library), _parties(parties), _numberOfSides(numberOfSides), _creaturesPerSide(creaturesPerSide) {
+        Battle(const BattleLibrary* library, std::vector<BattleParty> parties, bool canFlee = true,
+               uint8_t numberOfSides = 2, uint8_t creaturesPerSide = 1)
+            : _library(library), _parties(parties), _canFlee(canFlee), _numberOfSides(numberOfSides),
+              _creaturesPerSide(creaturesPerSide) {
             _sides = std::vector<BattleSide*>(numberOfSides);
             for (size_t i = 0; i < numberOfSides; i++) {
                 _sides[i] = new BattleSide(i, this, creaturesPerSide);
@@ -44,6 +47,8 @@ namespace CreatureLib::Battling {
         virtual bool CanUse(const BaseTurnChoice* choice);
         virtual bool TrySetChoice(BaseTurnChoice* choice);
 
+        bool CanFlee() const { return _canFlee; }
+
         void CheckChoicesSetAndRun();
 
         [[nodiscard]] ChoiceQueue* GetCurrentTurnQueue() const;
@@ -63,7 +68,7 @@ namespace CreatureLib::Battling {
 
         void ValidateBattleState();
         inline bool HasEnded() const { return _hasEnded; }
-        inline uint8_t GetResult() const { return _battleResult; }
+        inline const BattleResult& GetResult() const { return _battleResult; }
 
         const std::vector<BattleSide*>& GetSides() const { return _sides; }
     };

src/Battling/Models/BattleResult.hpp

@@ -0,0 +1,25 @@
+#ifndef CREATURELIB_BATTLERESULT_HPP
+#define CREATURELIB_BATTLERESULT_HPP
+
+#include <cstdint>
+namespace CreatureLib::Battling {
+    class BattleResult {
+        bool _conclusiveResult;
+        uint8_t _winningSide;
+
+        BattleResult(bool conclusiveResult, uint8_t winningSide)
+            : _conclusiveResult(conclusiveResult), _winningSide(winningSide) {}
+
+    public:
+        static BattleResult Inconclusive() { return BattleResult(false, 0); }
+        static BattleResult Conclusive(uint8_t winner) { return BattleResult(true, winner); }
+        static BattleResult Empty() { return BattleResult(false, 0); }
+
+        /// Whether or not the battle has ended with a conclusive result.
+        bool IsConclusiveResult() const { return _conclusiveResult; }
+        /// Get the index of the side that has won the battle. Only valid if the battle has a conclusive result.
+        uint8_t GetWinningSide() const { return _winningSide; }
+    };
+}
+
+#endif // CREATURELIB_BATTLERESULT_HPP

src/Battling/Models/BattleSide.hpp

@@ -15,6 +15,7 @@ namespace CreatureLib::Battling {
         uint8_t _choicesSet = 0;
         ScriptSet _volatile;
         Battle* _battle;
+        bool _hasFled = false;
 
     public:
         explicit BattleSide(uint8_t index, Battle* battle, uint8_t creaturesPerSide)
@@ -74,6 +75,10 @@ namespace CreatureLib::Battling {
             }
             return true;
         }
+
+        bool HasFled() { return _hasFled; }
+
+        void MarkAsFled() { _hasFled = true; }
     };
 }