CreatureLib/src/Battling/Models/Creature.cpp

#include "Creature.hpp"
#include <algorithm>
#include <utility>
#include "../Models/Battle.hpp"
#include "../ScriptHandling/ScriptMacros.hpp"

using namespace CreatureLib;

Battling::Creature::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& nickname,
                             const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks,
                             bool allowedExperienceGain)
    : _library(library), _species(species), _variant(variant), _level(level), _experience(experience),
      _uniqueIdentifier(uid), _gender(gender), _coloring(coloring), _heldItem(heldItem), _nickname(std::move(nickname)),
      _talentIndex(talent), _hasOverridenTalent(false), _attacks(attacks),
      _allowedExperienceGain(allowedExperienceGain) {
    AssertNotNull(library)
    AssertNotNull(species)
    AssertNotNull(variant)

    _activeTalent = std::unique_ptr<Script>(_library->LoadScript(ScriptCategory::Talent, GetActiveTalent()));
    if (_nickname.empty()) {
        _nickname = species->GetName().std_str();
    }
    for (auto t : _variant->GetTypes()) {
        _types.insert(t);
    }
}

void Battling::Creature::ChangeVariant(ArbUt::BorrowedPtr<const Library::SpeciesVariant> variant) {
    AssertNotNull(variant)
    _variant = variant;

    // Set the types to the new variant.
    _types.clear();
    for (auto t : variant->GetTypes()) {
        _types.insert(t);
    }

    // Grab the new active talent.
    _activeTalent =
        std::unique_ptr<CreatureLib::Battling::Script>(_library->LoadScript(ScriptCategory::Talent, GetActiveTalent()));

    // We modify the health of the creature by the change in its max health.
    auto prevHealth = GetBoostedStat(CreatureLib::Library::Statistic::Health);
    RecalculateFlatStats();
    int32_t diffHealth = GetBoostedStat(CreatureLib::Library::Statistic::Health) - prevHealth;
    if (_currentHealth < static_cast<uint32_t>(INT32_MAX) && static_cast<int32_t>(_currentHealth) < -diffHealth) {
        _currentHealth = 0;
    } else {
        _currentHealth += diffHealth;
    }

    // TODO: consider variant specific attacks?
}

void Battling::Creature::ChangeLevelBy(int8_t amount) {
    auto level = _level + amount;
    if (level > _library->GetSettings()->GetMaximalLevel())
        level = _library->GetSettings()->GetMaximalLevel();
    if (level < 1)
        level = 1;
    _level = level;
    _experience = _library->GetGrowthRateLibrary()->CalculateExperience(_species->GetGrowthRate(), _level);
    RecalculateFlatStats();
}

const ArbUt::StringView& Battling::Creature::GetActiveTalent() const {
    if (_hasOverridenTalent) {
        return _overridenTalentName;
    }
    return _variant->GetTalent(_talentIndex);
}

void Battling::Creature::SetBattleData(ArbUt::BorrowedPtr<Battle> battle, ArbUt::BorrowedPtr<BattleSide> side) {
    _battle = battle;
    _side = side;
    this->ResetActiveScripts();
}

// region Stat APIs

bool Battling::Creature::ChangeStatBoost(Library::Statistic stat, int8_t diffAmount) {
    bool changed = false;
    if (diffAmount > 0)
        changed = this->_statBoost.IncreaseStatBy(stat, diffAmount);
    else
        changed = this->_statBoost.DecreaseStatBy(stat, -diffAmount);
    this->RecalculateBoostedStat(stat);
    return changed;
}

void Battling::Creature::RecalculateFlatStats() {
    auto& statCalc = this->_library->GetStatCalculator();
    this->_flatStats = statCalc->CalculateFlatStats(this);
    RecalculateBoostedStats();
}
void Battling::Creature::RecalculateBoostedStats() {
    this->_boostedStats = this->_library->GetStatCalculator()->CalculateFlatStats(this);
}

void Battling::Creature::RecalculateFlatStat(Library::Statistic stat) {
    auto s = this->_library->GetStatCalculator()->CalculateFlatStat(this, stat);
    this->_flatStats.SetStat(stat, s);
    RecalculateBoostedStat(stat);
}

void Battling::Creature::RecalculateBoostedStat(Library::Statistic stat) {
    auto s = this->_library->GetStatCalculator()->CalculateBoostedStat(this, stat);
    this->_boostedStats.SetStat(stat, s);
}

// endregion

const ArbUt::BorrowedPtr<CreatureLib::Battling::Battle>& Battling::Creature::GetBattle() const { return _battle; }

const ArbUt::BorrowedPtr<CreatureLib::Battling::BattleSide>& Battling::Creature::GetBattleSide() const { return _side; }

bool Battling::Creature::IsFainted() const noexcept { return this->_currentHealth == 0; }

void Battling::Creature::OnFaint() {
    // HOOK: On Faint
    if (_battle != nullptr) {
        _battle->TriggerEventListener<FaintEvent>(this);
    }
    _library->GetExperienceLibrary()->HandleExperienceGain(this, _seenOpponents);
    auto sideIndex = _side->GetCreatureIndex(this);
    if (!_battle->CanSlotBeFilled(_side->GetSideIndex(), sideIndex)) {
        _side->MarkSlotAsUnfillable(this);
    }
    _battle->ValidateBattleState();
}

void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source) {
    if (damage > _currentHealth) {
        damage = _currentHealth;
    }
    if (damage == 0)
        return;
    // HOOK: On Damage
    auto newHealth = _currentHealth - damage;
    auto battle = this->GetBattle();
    if (battle != nullptr) {
        battle->TriggerEventListener<DamageEvent>(this, source, _currentHealth, newHealth);
    }
    _currentHealth = newHealth;

    if (IsFainted() && damage > 0) {
        OnFaint();
    }
}

void Battling::Creature::Heal(uint32_t amount, bool canRevive) {
    if (_currentHealth == 0 && !canRevive) {
        return;
    }
    if (amount > GetMaxHealth() - _currentHealth) {
        amount = GetMaxHealth() - _currentHealth;
    }
    // HOOK: On Heal
    auto newHealth = _currentHealth + amount;
    auto battle = this->GetBattle();
    if (battle != nullptr) {
        battle->TriggerEventListener<HealEvent>(this, _currentHealth, newHealth);
    }
    _currentHealth = newHealth;
}

void Battling::Creature::OverrideActiveTalent(const ArbUt::StringView& talent) {
    _hasOverridenTalent = true;
    _activeTalent->OnRemove();
    _overridenTalentName = talent;
    _activeTalent.reset(this->_library->LoadScript(ScriptCategory::Talent, talent));
}

const std::unordered_set<uint8_t>& Battling::Creature::GetTypes() const noexcept { return _types; }

bool Battling::Creature::HasType(uint8_t type) const noexcept {
    return std::find(_types.begin(), _types.end(), type) != _types.end();
}

size_t Battling::Creature::ScriptCount() const {
    auto c = 3;
    if (_side != nullptr) {
        c += _side->ScriptCount();
    }
    return c;
}

void Battling::Creature::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) {
    scripts.Append(ScriptWrapper::FromScript(&_activeTalent));
    scripts.Append(ScriptWrapper::FromScript(&_status));
    scripts.Append(ScriptWrapper::FromSet(&_volatile));
    if (_side != nullptr) {
        _side->GetActiveScripts(scripts);
    }
}
void Battling::Creature::ClearVolatileScripts() { _volatile.Clear(); }
void Battling::Creature::AddExperience(uint32_t amount) {
    auto maxLevel = _library->GetSettings()->GetMaximalLevel();
    if (_level >= maxLevel) {
        return;
    }
    auto exp = _experience + amount;
    auto level = _library->GetGrowthRateLibrary()->CalculateLevel(this->GetSpecies()->GetGrowthRate(), exp);
    if (level >= maxLevel) {
        exp = _library->GetGrowthRateLibrary()->CalculateExperience(this->GetSpecies()->GetGrowthRate(), maxLevel);
    }
    _experience = exp;
    _level = level;
}
ArbUt::BorrowedPtr<const Library::CreatureSpecies> Battling::Creature::GetDisplaySpecies() const noexcept {
    auto species = _displaySpecies;
    if (species == nullptr)
        species = _species;
    return species;
}
ArbUt::BorrowedPtr<const Library::SpeciesVariant> Battling::Creature::GetDisplayVariant() const noexcept {
    auto variant = _displayVariant;
    if (variant == nullptr)
        variant = _variant;
    return variant;
}
void Battling::Creature::SetHeldItem(const ArbUt::BasicStringView& itemName) {
    ArbUt::BorrowedPtr<const Library::Item> item;
    if (!_library->GetItemLibrary()->TryGet(itemName.GetHash(), item)) {
        THROW_CREATURE("Item not found '" << itemName.c_str() << "'.");
    }
    _heldItem = item;
}
void Battling::Creature::SetHeldItem(uint32_t itemNameHash) {
    ArbUt::BorrowedPtr<const Library::Item> item;
    if (!_library->GetItemLibrary()->TryGet(itemNameHash, item)) {
        THROW_CREATURE("Item not found.");
    }
    _heldItem = item;
}

void Battling::Creature::AddVolatileScript(const ArbUt::StringView& name) {
    auto script = _volatile.Get(name);
    if (script != nullptr) {
        script->Stack();
        return;
    }
    script = this->_library->LoadScript(ScriptCategory::Creature, name);
    if (script == nullptr) {
        THROW_CREATURE("Invalid volatile script requested for creature: '" << name.c_str() << "'.");
    }
    _volatile.Add(script.GetRaw());
}

void Battling::Creature::AddVolatileScript(Script* script) { _volatile.Add(script); }
void Battling::Creature::RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
void Battling::Creature::RemoveVolatileScript(Battling::Script* script) { _volatile.Remove(script->GetName()); }
bool Battling::Creature::HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }