st-actor.h

Go to the documentation of this file.

#pragma once
#include <vector>
 
#include "st-misc.h"
 
namespace StyyxUtil
{
 
struct ActorUtil
{
    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)
    {
        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->HasKeywordWithType(RE::DEFAULT_OBJECT::kKeywordVampire))
        {
            return true;
        }
        return false;
    }

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

    static bool IsDragon(const RE::Actor *a_actor)
    {
        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)
    {
        return a_actor->GetActorValueModifier(RE::ACTOR_VALUE_MODIFIER::kTemporary, RE::ActorValue::kHealth) +
               a_actor->GetPermanentActorValue(RE::ActorValue::kHealth);
    }

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

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

    static void FullyHealActor(RE::Actor *a_actor)
    {
        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 (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)
    {
        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) {
 
        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(0, 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