CreatureLib/src/Battling/Models/Battle.hpp

#ifndef CREATURELIB_BATTLE_HPP
#define CREATURELIB_BATTLE_HPP

#include <vector>
#include "../Flow/ChoiceQueue.hpp"
#include "../Library/BattleLibrary.hpp"
#include "../TurnChoices/BaseTurnChoice.hpp"
#include "BattleParty.hpp"
#include "BattleSide.hpp"
#include "CreatureIndex.hpp"

namespace CreatureLib::Battling {
    class Battle : public ScriptSource {
        const BattleLibrary* _library;
        std::vector<BattleParty> _parties;
        uint8_t _numberOfSides;
        uint8_t _creaturesPerSide;
        std::vector<BattleSide*> _sides;
        Core::Random _random;
        ChoiceQueue* _currentTurnQueue = nullptr;
        bool _hasEnded = false;
        uint8_t _battleResult = 0;

        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) {
            _sides = std::vector<BattleSide*>(numberOfSides);
            for (size_t i = 0; i < numberOfSides; i++) {
                _sides[i] = new BattleSide(i, this, creaturesPerSide);
            }
        }

        ~Battle() {
            for (auto s : _sides) {
                delete s;
            }
        }

        [[nodiscard]] const BattleLibrary* GetLibrary() const;

        virtual bool CanUse(const BaseTurnChoice* choice);
        virtual bool TrySetChoice(BaseTurnChoice* choice);

        void CheckChoicesSetAndRun();

        [[nodiscard]] ChoiceQueue* GetCurrentTurnQueue() const;
        Core::Random& GetRandom();

        bool CreatureInField(const Creature* creature) const;

        Creature* GetTarget(const CreatureIndex& target) {
            return _sides[target.GetSideIndex()]->GetCreature(target.GetCreatureIndex());
        }

        void ForceRecall(uint8_t side, uint8_t index);
        void SwitchCreature(uint8_t side, uint8_t index, Creature* c);
        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; }

        const std::vector<BattleSide*>& GetSides() const { return _sides; }
    };
}

#endif // CREATURELIB_BATTLE_HPP