st-actor.h

Go to the documentation of this file.

#pragma once
#include <vector>
 
#include "st-misc.h"
 
namespace StyyxUtil
{
 
struct ActorUtil
{

    static void InterruptAttack(RE::Actor* a_actor)
    {
 
        if (!a_actor)
            return;
 
        a_actor->NotifyAnimationGraph("attackStop");
        a_actor->NotifyAnimationGraph("blockStop");
    }

    static bool IsMoving(const RE::Actor* a_actor)
    {
        if (!a_actor)
        {
            return false;
        }
 
        return (static_cast<bool>(a_actor->actorState1.movingForward) ||
                static_cast<bool>(a_actor->actorState1.movingBack) ||
                static_cast<bool>(a_actor->actorState1.movingLeft) ||
                static_cast<bool>(a_actor->actorState1.movingRight));
    }

    [[nodiscard]] static bool IsGod(RE::Actor* a_actor)
    {
        if (!a_actor)
            return false;
        return a_actor->IsPlayerRef() && RE::PlayerCharacter::IsGodMode();
    }

    static bool CasterIsCastingObject(RE::ActorMagicCaster* a_caster)
    {
        if (!a_caster)
            return false;
        using ct = RE::MagicSystem::CastingType;
        switch (const auto type = a_caster->currentSpell->GetCastingType())
        {
            case ct::kScroll:
                return true;
            default:
                return false;
        }
    }

    static void GetPerksFromBaseActor(RE::Actor* a_actor, std::vector<RE::BGSPerk*>& perks)
    {
        if (!a_actor)
            return;
 
        const auto base = a_actor->GetActorBase();
        if (!base)
            return;
 
        const uint32_t perk_count = base->perkCount;
        for (uint32_t i = 0; i < perk_count; i++)
        {
            RE::BGSPerk* perk = base->perks[i].perk;
            if (!perk)
                continue;
            perks.push_back(perk);
        }
    }

    static bool ActorHasEquippedHeavyArmor(RE::Actor* actor)
    {
        if (!actor)
            return false;
        const auto proc = actor->currentProcess;
        if (!proc)
            return false;
 
        for (auto& [object, slot] : proc->equippedForms)
        {
            if (object)
            {
                if (const auto armor = object->As<RE::TESObjectARMO>())
                {
                    if (armor->IsHeavyArmor())
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    static bool ActorHasEquippedLightArmor(const RE::Actor* actor)
    {
        if (!actor)
            return false;
        const auto proc = actor->currentProcess;
        if (!proc)
            return false;
 
        for (auto& [object, slot] : proc->equippedForms)
        {
            if (object)
            {
                if (const auto armor = object->As<RE::TESObjectARMO>())
                {
                    if (!armor->IsHeavyArmor())
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    static bool IsInOpportunityState(RE::Actor* victim, const RE::Actor* attacker)
    {
 
        if (!victim || !attacker)
        {
            return false;
        }
 
        return IsPowerAttacking(victim) || victim->IsStaggering() ||
               victim->actorState1.sitSleepState == RE::SIT_SLEEP_STATE::kIsSitting ||
               victim->actorState1.sitSleepState == RE::SIT_SLEEP_STATE::kIsSleeping ||
               (victim->GetHeadingAngle(attacker->GetPosition(), false) <= -135 ||
                victim->GetHeadingAngle(attacker->GetPosition(), false) >= 135) ||
               ActorHasEffectOfTypeActive(victim, RE::EffectArchetypes::ArchetypeID::kParalysis) ||
               ActorHasEffectOfTypeActive(victim, RE::EffectArchetypes::ArchetypeID::kCalm);
    }

    static bool ActorHasQuestObjectInHand(RE::Actor* actor)
    {
        if (actor)
        {
            if (const auto* rightHandItem = actor->GetEquippedEntryData(false))
            {
                if (rightHandItem->IsQuestObject())
                {
                    return true;
                }
            }
 
            if (const auto* leftHandItem = actor->GetEquippedEntryData(true))
            {
                if (leftHandItem->IsQuestObject())
                {
                    return true;
                }
            }
        }
        return false;
    };

    static bool IsVampire(RE::Actor* a_ref)
    {
 
        if (!a_ref)
        {
            return false;
        }
 
        if (a_ref->HasKeywordWithType(RE::DEFAULT_OBJECT::kKeywordVampire))
        {
            return true;
        }
        return false;
    }

    static bool IsUndead(RE::Actor* a_ref)
    {
 
        if (!a_ref)
        {
            return false;
        }
 
        if (a_ref->HasKeywordWithType(RE::DEFAULT_OBJECT::kKeywordUndead))
            return true;
        return false;
    }

    static bool IsDragon(const RE::Actor* a_actor)
    {
 
        if (!a_actor)
        {
            return false;
        }
 
        if (a_actor->HasKeywordWithType(RE::DEFAULT_OBJECT::kKeywordDragon))
        {
            return true;
        }
        const auto key = RE::TESForm::LookupByEditorID<RE::BGSKeyword>("ActorTypeDragon");
        if (!key)
            return false;
        return a_actor->HasKeyword(key);
    }

    static RE::TESObjectCELL* GetPlayerCell()
    {
        const auto player = RE::PlayerCharacter::GetSingleton();
 
        auto cell = player->GetParentCell();
        if (!cell)
        {
            cell = player->GetSaveParentCell();
        }
        return cell;
    }

    static float GetCurrentLightLevel(const RE::Actor* a_actor)
    {
        if (!a_actor)
            return 0.0f;
 
        const auto process = a_actor->GetHighProcess();
        return process ? process->lightLevel : 0.0f;
    }

    static float GetCurrentLightLevelPlayer()
    {
        const auto player = RE::PlayerCharacter::GetSingleton();
        return GetCurrentLightLevel(player);
    }

 
    static void TryStagger(RE::Actor* a_target, float a_staggerMult, RE::Actor* a_aggressor)
    {
        using func_t = decltype(&TryStagger);
        static REL::Relocation<func_t> func{RELOCATION_ID(36700, 37710)};
        func(a_target, a_staggerMult, a_aggressor);
    }

 
    static bool StartsDead(const RE::Actor* actor)
    {
        return actor && (actor->formFlags & RE::Actor::RecordFlags::kStartsDead);
    }

 
    static float GetMaxHealth(RE::Actor* a_actor)
    {
 
        if (!a_actor)
        {
            return 0.f;
        }
 
        return a_actor->GetActorValueModifier(RE::ACTOR_VALUE_MODIFIER::kTemporary, RE::ActorValue::kHealth) +
               a_actor->GetPermanentActorValue(RE::ActorValue::kHealth);
    }

    static float GetMaxStamina(RE::Actor* actor)
    {
 
        if (!a_actor)
        {
            return 0.f;
        }
 
        return actor->GetActorValueModifier(RE::ACTOR_VALUE_MODIFIER::kTemporary, RE::ActorValue::kStamina) +
               actor->GetPermanentActorValue(RE::ActorValue::kStamina);
    }

    static float GetMaxMagicka(RE::Actor* actor)
    {
 
        if (!a_actor)
        {
            return 0.f;
        }
 
        return actor->GetActorValueModifier(RE::ACTOR_VALUE_MODIFIER::kTemporary, RE::ActorValue::kMagicka) +
               actor->GetPermanentActorValue(RE::ActorValue::kMagicka);
    }

    static void FullyHealActor(RE::Actor* a_actor)
    {
 
        if (!a_actor)
        {
            return;
        }
 
        a_actor->RestoreActorValue(RE::ActorValue::kHealth, GetMaxHealth(a_actor));
        a_actor->RestoreActorValue(RE::ActorValue::kStamina, GetMaxStamina(a_actor));
        a_actor->RestoreActorValue(RE::ActorValue::kMagicka, GetMaxMagicka(a_actor));
    }

    static bool ActorHasEffectOfTypeActive(RE::Actor* a_actor, RE::EffectArchetypes::ArchetypeID a_type)
    {
        if (!a_actor)
            return false;
 
        const auto& activeEffects = a_actor->GetActiveEffectList();
        if (!activeEffects)
            return false;
 
        return std::ranges::any_of(*activeEffects,
                                   [a_type](const RE::ActiveEffect* effect) -> bool
                                   {
                                       if (!effect || effect->flags.any(RE::ActiveEffect::Flag::kInactive))
                                           return false;
                                       const auto base = effect->GetBaseObject();
                                       return base && base->HasArchetype(a_type);
                                   });
    }

    static bool HasEffectWithKeywordActive(RE::Actor* a_actor, const std::string_view a_keyword)
    {
        if (!a_actor || a_keyword.empty() || !a_actor->Is3DLoaded())
        {
            return false;
        }
        const auto& activeEffects = a_actor->GetActiveEffectList();
        if (!activeEffects)
            return false;
 
        if (const auto key = RE::TESForm::LookupByEditorID<RE::BGSKeyword>(a_keyword))
        {
            return std::ranges::any_of(*activeEffects,
                                       [key](const RE::ActiveEffect* effect) -> bool
                                       {
                                           if (!effect || effect->flags.any(RE::ActiveEffect::Flag::kInactive))
                                               return false;
                                           const auto base = effect->GetBaseObject();
                                           return base && base->HasKeyword(key);
                                       });
        }
        return std::ranges::any_of(*activeEffects,
                                   [a_keyword](const RE::ActiveEffect* effect) -> bool
                                   {
                                       if (!effect || effect->flags.any(RE::ActiveEffect::Flag::kInactive))
                                           return false;
                                       const auto base = effect->GetBaseObject();
                                       return base && base->HasKeywordString(a_keyword);
                                   });
    }

    static bool IsEffectActive(RE::Actor* a_actor, const RE::EffectSetting* a_effect)
    {
        if (!a_actor || !a_effect)
        {
            return false;
        }
        const auto& activeEffects = a_actor->GetActiveEffectList();
        if (!activeEffects)
            return false;
 
        return std::ranges::any_of(*activeEffects,
                                   [a_effect](const RE::ActiveEffect* effect) -> bool
                                   {
                                       if (!effect || effect->flags.any(RE::ActiveEffect::Flag::kInactive))
                                           return false;
                                       const auto base = effect->GetBaseObject();
                                       return base == a_effect;
                                   });
    }

    static void AddItem(RE::Actor* a_actor, RE::TESBoundObject* a_item, RE::ExtraDataList* a_extraList, int a_count,
                        RE::TESObjectREFR* a_fromRefr)
    {
        using func_t = decltype(AddItem);
        static REL::Relocation<func_t> func{RELOCATION_ID(36525, 37525)};
        return func(a_actor, a_item, a_extraList, a_count, a_fromRefr);
    }

    static void AddItemPlayer(RE::TESBoundObject* a_item, const int a_count)
    {
        return AddItem(RE::PlayerCharacter::GetSingleton(), a_item, nullptr, a_count, nullptr);
    }

    static int RemoveItemPlayer(RE::TESBoundObject* item, int count)
    {
        using func_t = decltype(RemoveItemPlayer);
        static REL::Relocation<func_t> func{RELOCATION_ID(16564, 16919)};
        return func(item, count);
    }

    static bool ActorHasItem(RE::Actor* actor, RE::TESBoundObject* item)
    {
        if (!actor || !item)
            return false;
 
        const auto& inv = actor->GetInventory();
        const auto it   = inv.find(item);
        return it != inv.end() && it->second.first > 0;
    }

    static RE::TESObjectWEAP* GetWieldingWeapon(RE::Actor* a_actor)
    {
 
        if (!a_actor)
        {
            return nullptr;
        }
 
        if (const auto weapon = a_actor->GetAttackingWeapon())
        {
            const auto obj = weapon->object;
            return obj ? obj->As<RE::TESObjectWEAP>() : nullptr;
        }
        if (const auto rhs = a_actor->GetEquippedObject(false); rhs && rhs->IsWeapon())
        {
            return rhs->As<RE::TESObjectWEAP>();
        }
        if (const auto lhs = a_actor->GetEquippedObject(true); lhs && lhs->IsWeapon())
        {
            return lhs->As<RE::TESObjectWEAP>();
        }
 
        return nullptr;
    }

    static RE::Actor* GetPlayerMount()
    {
        RE::NiPointer<RE::Actor> currentMount;
        if (RE::PlayerCharacter::GetSingleton()->GetMount(currentMount))
        {
            return currentMount.get();
        }
        return nullptr;
    }

    static bool IsPowerAttacking(const RE::Actor* actor)
    {
 
        if (!actor)
            return false;
 
        const auto high = actor->GetHighProcess();
        if (!high)
            return false;
 
        const auto& attackData = high->attackData;
        if (!attackData)
            return false;
 
        return attackData->data.flags.any(RE::AttackData::AttackFlag::kPowerAttack);
    }

    static bool IsBashing(const RE::Actor* actor)
    {
 
        if (!actor)
            return false;
 
        const auto high = actor->GetHighProcess();
 
        if (!high)
            return false;
 
        if (actor->GetAttackState() == RE::ATTACK_STATE_ENUM::kNone)
            return false;
 
        const auto& attackData = high->attackData;
        if (!attackData)
            return false;
 
        return attackData->data.flags.any(RE::AttackData::AttackFlag::kBashAttack);
    }

    static std::vector<RE::Actor*> GetNearbyActors(const RE::TESObjectREFR* a_ref, const float a_radius,
                                                   const bool a_ignorePlayer)
    {
        std::vector<RE::Actor*> result;
        const auto processLists = RE::ProcessLists::GetSingleton();
        if (!processLists)
            return result;
 
        if (a_ignorePlayer && processLists->numberHighActors == 0)
            return result;
 
        const auto squaredRadius = a_radius * a_radius;
        const auto originPos     = a_ref->GetPosition();
 
        result.reserve(processLists->numberHighActors);
 
        const auto get_actor_within_radius = [&](RE::Actor* a_actor)
        {
            if (a_actor && a_actor != a_ref && originPos.GetSquaredDistance(a_actor->GetPosition()) <= squaredRadius)
            {
                result.emplace_back(a_actor);
            }
        };
        for (auto& actorHandle : processLists->highActorHandles)
        {
            const auto actor = actorHandle.get();
            get_actor_within_radius(actor.get());
        }
 
        if (!a_ignorePlayer)
        {
            get_actor_within_radius(RE::PlayerCharacter::GetSingleton());
        }
 
        return result;
    }

    static std::vector<RE::Actor*> GetNearbyNonPlayerTeammates(const RE::TESObjectREFR* a_ref, const float a_radius)
    {
        auto actors = GetNearbyActors(a_ref, a_radius, true);
        std::erase_if(actors, [](const RE::Actor* a) { return a->IsPlayerTeammate(); });
        return actors;
    }

    static bool IsGuardNearby(const RE::TESObjectREFR* a_ref, const float a_radius)
    {
        return std::ranges::any_of(GetNearbyActors(a_ref, a_radius, false),
                                   [](const RE::Actor* a) { return a && a->IsGuard(); });
    }

    static RE::Actor* GetClosestActor(const RE::TESObjectREFR* a_ref, const float a_radius)
    {
        const auto nearby_actors = GetNearbyActors(a_ref, a_radius, false);
        return GetClosestFromVector(a_ref, nearby_actors);
    }

    static RE::Actor* GetClosestNonPlayerTeammate(const RE::TESObjectREFR* a_ref, const float a_radius)
    {
        const auto nearby_actors = GetNearbyNonPlayerTeammates(a_ref, a_radius);
        return GetClosestFromVector(a_ref, nearby_actors);
    }

    static void SetNPCLevel(RE::Actor* actor, uint16_t level)
    {
        MiscUtil::RunConsoleCommandOnRef(actor, std::format("SetLevel {}", level));
    }

    static float GetActorValuePercentage(RE::Actor* a_actor, RE::ActorValue a_av)
    {
        using func_t = decltype(&GetActorValuePercentage);
        static REL::Relocation<func_t> func{RELOCATION_ID(36347, 37337)};
        return func(a_actor, a_av);
    }
 
  private:
    static RE::Actor* GetClosestFromVector(const RE::TESObjectREFR* a_ref, const std::vector<RE::Actor*>& actors)
    {
        if (actors.empty())
            return nullptr;
        const auto originPos = a_ref->GetPosition();
        const auto it        = std::ranges::min_element(actors,
                                                        [&](RE::Actor* a, RE::Actor* b)
                                                        {
                                                     return originPos.GetSquaredDistance(a->GetPosition()) <
                                                            originPos.GetSquaredDistance(b->GetPosition());
                                                        });
        return it != actors.end() ? *it : nullptr;
    }
};
 
} // namespace StyyxUtil