CreatureLib/src/Battling/Models/Creature.hpp

#ifndef CREATURELIB_BATTLECREATURE_HPP
#define CREATURELIB_BATTLECREATURE_HPP

#include <Arbutils/Collections/List.hpp>
#include <Arbutils/Memory/BorrowedPtr.hpp>
#include <Arbutils/Memory/UniquePtrList.hpp>
#include "../../Library/ClampedStatisticSet.hpp"
#include "../../Library/CreatureData/CreatureSpecies.hpp"
#include "../../Library/Items/Item.hpp"
#include "../ScriptHandling/ScriptAggregator.hpp"
#include "../ScriptHandling/ScriptSet.hpp"
#include "../ScriptHandling/ScriptSource.hpp"
#include "DamageSource.hpp"
#include "LearnedAttack.hpp"

namespace CreatureLib::Battling {
    // Forward declare battle class
    class Battle;
    class BattleSide;
    class BattleLibrary;

    class Creature : public ScriptSource {
    protected:
        ArbUt::BorrowedPtr<const BattleLibrary> _library;

        ArbUt::BorrowedPtr<const Library::CreatureSpecies> _species;
        ArbUt::BorrowedPtr<const Library::SpeciesVariant> _variant;

        ArbUt::BorrowedPtr<const Library::CreatureSpecies> _displaySpecies = nullptr;
        ArbUt::BorrowedPtr<const Library::SpeciesVariant> _displayVariant = nullptr;

        uint8_t _level;
        uint32_t _experience;
        uint32_t _uniqueIdentifier;
        Library::Gender _gender;
        uint8_t _coloring;
        ArbUt::BorrowedPtr<const Library::Item> _heldItem;
        uint32_t _currentHealth = -1;

        Library::ClampedStatisticSet<int8_t, -6, 6> _statBoost;
        Library::StatisticSet<uint32_t> _flatStats;
        Library::StatisticSet<uint32_t> _boostedStats;

        ArbUt::BorrowedPtr<Battle> _battle = nullptr;
        ArbUt::BorrowedPtr<BattleSide> _side = nullptr;
        bool _onBattleField = false;

        std::string_view _nickname = "";
        CreatureLib::Library::TalentIndex _talentIndex;
        std::unique_ptr<Script> _activeTalent = nullptr;

        bool _hasOverridenTalent;
        ArbUt::StringView _overridenTalentName = ""_cnc;
        std::unordered_set<ArbUt::BorrowedPtr<Creature>> _seenOpponents;

        ArbUt::UniquePtrList<LearnedAttack> _attacks;
        bool _allowedExperienceGain;

        std::unique_ptr<Script> _status = nullptr;
        ScriptSet _volatile = {};

        std::unordered_set<uint8_t> _types;

    private:
        void OnFaint();

    public:
        Creature(ArbUt::BorrowedPtr<const BattleLibrary> library,
                 const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
                 const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, uint8_t level, uint32_t experience,
                 uint32_t uid, Library::Gender gender, uint8_t coloring,
                 const ArbUt::BorrowedPtr<const Library::Item> heldItem, const std::string_view& nickname,
                 const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks,
                 bool allowedExperienceGain = true);

        virtual ~Creature() = default;

        virtual void Initialize() {
            RecalculateFlatStats();
            _currentHealth = GetBoostedStat(Library::Statistic::Health);
        }

        inline const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& GetSpecies() const noexcept {
            return _species;
        }
        inline const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& GetVariant() const noexcept { return _variant; }
        virtual void ChangeVariant(ArbUt::BorrowedPtr<const Library::SpeciesVariant> variant);
        inline uint8_t GetLevel() const noexcept { return _level; }
        inline uint32_t GetExperience() const noexcept { return _experience; }
        inline Library::Gender GetGender() const noexcept { return _gender; }
        inline uint8_t GetColoring() const noexcept { return _coloring; }
        inline bool HasHeldItem(const ArbUt::BasicStringView& name) const noexcept {
            return _heldItem != nullptr && _heldItem->GetName() == name;
        }
        inline bool HasHeldItem(uint32_t nameHash) const noexcept {
            return _heldItem != nullptr && _heldItem->GetName() == nameHash;
        }
        inline const ArbUt::BorrowedPtr<const Library::Item>& GetHeldItem() const noexcept { return _heldItem; }
        void SetHeldItem(const ArbUt::BasicStringView& itemName);
        void SetHeldItem(uint32_t itemNameHash);
        inline void SetHeldItem(const ArbUt::BorrowedPtr<const Library::Item>& item) noexcept { _heldItem = item; };

        inline uint32_t GetCurrentHealth() const noexcept { return _currentHealth; }

        void SetBattleData(ArbUt::BorrowedPtr<Battle> battle, ArbUt::BorrowedPtr<BattleSide> side);
        const ArbUt::BorrowedPtr<Battle>& GetBattle() const;
        const ArbUt::BorrowedPtr<BattleSide>& GetBattleSide() const;
        inline void SetOnBattleField(bool value) { _onBattleField = value; }
        inline bool IsOnBattleField() const { return _onBattleField; }

        inline const std::string_view& GetNickname() const noexcept { return _nickname; }
        const ArbUt::StringView& GetActiveTalent() const;

        [[nodiscard]] bool IsFainted() const noexcept;
        [[nodiscard]] const std::unordered_set<uint8_t>& GetTypes() const noexcept;
        [[nodiscard]] bool HasType(uint8_t type) const noexcept;

        uint32_t GetMaxHealth() const noexcept { return _boostedStats.GetHealth(); }
        void ChangeLevelBy(int8_t amount);
        void Damage(uint32_t damage, DamageSource source);
        void Heal(uint32_t amount, bool canRevive = false);
        void OverrideActiveTalent(const ArbUt::StringView& talent);
        void AddExperience(uint32_t amount);

        void MarkOpponentAsSeen(ArbUt::BorrowedPtr<Creature> creature) { _seenOpponents.insert(creature); }
        const std::unordered_set<ArbUt::BorrowedPtr<Creature>>& GetSeenOpponents() const { return _seenOpponents; }

        size_t ScriptCount() const override;
        void GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) override;
        void ClearVolatileScripts();
        void AddVolatileScript(const ArbUt::BasicStringView& name);
        void AddVolatileScript(Script* script);
        void RemoveVolatileScript(const ArbUt::BasicStringView& name);
        void RemoveVolatileScript(Script* script);
        bool HasVolatileScript(const ArbUt::BasicStringView& name) const;

        const ArbUt::UniquePtrList<LearnedAttack>& GetAttacks() noexcept { return _attacks; }

        ArbUt::BorrowedPtr<const Library::CreatureSpecies> GetDisplaySpecies() const noexcept;
        ArbUt::BorrowedPtr<const Library::SpeciesVariant> GetDisplayVariant() const noexcept;

        void SetDisplaySpecies(const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species) noexcept {
            _displaySpecies = species;
        }
        void SetDisplayVariant(ArbUt::BorrowedPtr<const Library::SpeciesVariant> variant) noexcept {
            _displayVariant = variant;
        };

        inline bool AllowedExperienceGain() const noexcept { return _allowedExperienceGain; }
        inline void SetAllowedExperienceGain(bool allowed) noexcept { _allowedExperienceGain = allowed; }

        // region Stat APIs

        bool ChangeStatBoost(Library::Statistic stat, int8_t diffAmount);
        [[nodiscard]] inline uint32_t GetFlatStat(Library::Statistic stat) const { return _flatStats.GetStat(stat); }
        [[nodiscard]] inline uint32_t GetBoostedStat(Library::Statistic stat) const {
            return _boostedStats.GetStat(stat);
        }
        [[nodiscard]] inline uint32_t GetBaseStat(Library::Statistic stat) const {
            return _variant->GetStatistic(stat);
        }
        [[nodiscard]] inline int8_t GetStatBoost(Library::Statistic stat) const { return _statBoost.GetStat(stat); }
        void RecalculateFlatStats();
        void RecalculateBoostedStats();
        void RecalculateFlatStat(Library::Statistic);
        void RecalculateBoostedStat(Library::Statistic);

        // endregion
    };
}

#endif // CREATURELIB_CREATURE_HPP