CreatureLib/src/Battling/Models/BattleSide.hpp

#ifndef CREATURELIB_BATTLESIDE_HPP
#define CREATURELIB_BATTLESIDE_HPP

#include <vector>
#include "../TurnChoices/BaseTurnChoice.hpp"
#include "Creature.hpp"

namespace CreatureLib::Battling {
    class BattleSide : public ScriptSource {
        uint8_t _index;
        uint8_t _creaturesPerSide;
        std::vector<Creature*> _creatures;
        std::vector<BaseTurnChoice*> _choices;
        std::vector<bool> _fillableSlots;
        uint8_t _choicesSet = 0;
        ScriptSet _volatile;
        Battle* _battle;
        bool _hasFled = false;

    public:
        explicit BattleSide(uint8_t index, Battle* battle, uint8_t creaturesPerSide)
            : _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();
        }

        virtual ~BattleSide() = default;

        [[nodiscard]] bool AllChoicesSet() const;
        [[nodiscard]] const std::vector<BaseTurnChoice*>& GetChoices() const;

        [[nodiscard]] bool AllPossibleSlotsFilled() const;

        void SetChoice(BaseTurnChoice* choice);
        void ResetChoices();

        void SetCreature(Creature* creature, uint8_t index);

        Creature* GetCreature(uint8_t index) const;
        bool CreatureOnSide(const Creature* creature) const;

        void GetActiveScripts(std::vector<ScriptWrapper>& scripts) final;

        const std::vector<Creature*>& GetCreatures() { return _creatures; }

        uint8_t GetSideIndex() { return _index; }
        uint8_t GetCreatureIndex(Creature* c) {
            for (size_t i = 0; i < _creatures.size(); i++) {
                if (c == _creatures[i])
                    return i;
            }
            throw CreatureException("Unable to find creature on field.");
        }

        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;
        }

        bool HasFled() { return _hasFled; }

        void MarkAsFled() { _hasFled = true; }

        uint8_t GetRandomCreatureIndex();
    };
}

#endif // CREATURELIB_BATTLESIDE_HPP