docs: add plugin setup guide

plugin/lib/commonlibf4/include/RE/A/ACTION_OBJECT.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	class ACTION_OBJECT
+	{
+	public:
+		// members
+		TESForm*      form;   // 00
+		std::uint32_t flags;  // 08
+	};
+	static_assert(sizeof(ACTION_OBJECT) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_AGGRESSION.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_AGGRESSION : std::uint32_t
+	{
+		kCalmed = 0xFFFFFFFF,
+		kUnagressive = 0x0,
+		kAggressive = 0x1,
+		kVeryAggressive = 0x2,
+		kFrenzied = 0x3,
+		kMax = 0x3
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_AGGRO_RADIUS.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_AGGRO_RADIUS : std::uint32_t
+	{
+		kWarn = 0x0,
+		kWarnAndAttack = 0x1,
+		kAttack = 0x2,
+		kCount = 0x3
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_ASSISTANCE.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_ASSISTANCE : std::uint32_t
+	{
+		kHelpsNobody = 0x0,
+		kHelpsAllies = 0x1,
+		kHelpsFriends = 0x2,
+		kCount = 0x3
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_BASE_DATA.h

@@ -0,0 +1,61 @@
+#pragma once
+
+namespace RE
+{
+	class ACTOR_BASE_DATA
+	{
+	public:
+		enum class Flag
+		{
+			kNone = 0,
+			kFemale = 1 << 0,
+			kEssential = 1 << 1,
+			kIsChargenFacePreset = 1 << 2,
+			kRespawn = 1 << 3,
+			kAutoCalcStats = 1 << 4,
+			kUnique = 1 << 5,
+			kDoesntAffectStealthMeter = 1 << 6,
+			kPCLevelMult = 1 << 7,
+			kUsesTemplate = 1 << 8,
+			kProtected = 1 << 11,
+			kSummonable = 1 << 14,
+			kDoesntBleed = 1 << 16,
+			kBleedoutOverride = 1 << 18,
+			kOppositeGenderanims = 1 << 19,
+			kSimpleActor = 1 << 20,
+			kLoopedScript = 1 << 21,  // ?
+			kLoopedAudio = 1 << 28,   // ?
+			kIsGhost = 1 << 29,
+			kInvulnerable = 1 << 31
+		};
+
+		enum class TEMPLATE_USE_FLAG
+		{
+			kNone = 0,
+			kTraits = 1 << 0,
+			kStats = 1 << 1,
+			kFactions = 1 << 2,
+			kSpells = 1 << 3,
+			kAIData = 1 << 4,
+			kAIPackages = 1 << 5,
+			kUnused = 1 << 6,
+			kBaseData = 1 << 7,
+			kInventory = 1 << 8,
+			kScript = 1 << 9,
+			kAIDefPackList = 1 << 10,
+			kAttackData = 1 << 11,
+			kKeywords = 1 << 12
+		};
+
+		// members
+		REX::TEnumSet<Flag, std::uint32_t>              actorBaseFlags;    // 00
+		std::int16_t                                    xpValueOffset;     // 04
+		std::uint16_t                                   level;             // 06
+		std::uint16_t                                   calcLevelMin;      // 08
+		std::uint16_t                                   calcLevelMax;      // 0A
+		std::uint16_t                                   baseDisposition;   // 0C
+		REX::TEnumSet<TEMPLATE_USE_FLAG, std::uint16_t> templateUseFlags;  // 0E
+		std::int16_t                                    bleedoutOverride;  // 10
+	};
+	static_assert(sizeof(ACTOR_BASE_DATA) == 0x14);
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_COMBAT_STATE.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_COMBAT_STATE : std::int32_t
+	{
+		kNone = 0x0,
+		kCombat = 0x1,
+		kSearching = 0x2
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_CONFIDENCE.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_CONFIDENCE : std::uint32_t
+	{
+		kCowardly = 0x0,
+		kCautious = 0x1,
+		kAverage = 0x2,
+		kBrave = 0x3,
+		kFoolhardy = 0x4,
+		kCount = 0x5
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_CRITICAL_STAGE.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_CRITICAL_STAGE : std::int32_t
+	{
+		kNone = 0x0,
+		kGooStart = 0x1,
+		kGooEnd = 0x2,
+		kDisintegrateStart = 0x3,
+		kDisintegrateEnd = 0x4,
+		kFreezeStart = 0x5,
+		kFreezeEnd = 0x6,
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_LIFE_STATE.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_LIFE_STATE : std::int32_t
+	{
+		kAlive = 0x0,
+		kDying = 0x1,
+		kDead = 0x2,
+		kUnconscious = 0x3,
+		kReanimate = 0x4,
+		kRecycle = 0x5,
+		kRestrained = 0x6,
+		kEssentialDown = 0x7,
+		kBleedout = 0x8
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_LOS_LOCATION.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_LOS_LOCATION : std::int32_t
+	{
+		kNone = 0x0,
+		kEye = 0x1,
+		kHead = 0x2,
+		kTorse = 0x3,
+		kFeet = 0x4,
+		kCount = 0x5
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_MOVEMENT_TYPE.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_MOVEMENT_TYPE : std::uint32_t
+	{
+		kWalk = 0x0,
+		kRun = 0x1,
+		kSneak = 0x2,
+		kBleedout = 0x3,
+		kSwim = 0x4
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_STANCE.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_STANCE : std::uint32_t
+	{
+		kNormal = 0x0,
+		kSneaking = 0x1,
+		kCoverVeryLow = 0x2,
+		kCoverLow = 0x3,
+		kCoverMid = 0x4,
+		kCoverHigh = 0x5,
+		kCount = 0x6
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_VALUE_MODIFIER.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_VALUE_MODIFIER : std::int32_t
+	{
+		kPermanent = 0,
+		kTemporary = 1,
+		kDamage = 2
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ACTOR_VISIBILITY_MASK.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_VISIBILITY_MASK : std::uint32_t
+	{
+		kFrustrum = 1 << 0,
+		kOcclusion = 1 << 1,
+		kFaded = 1 << 2,
+		kAll = kFrustrum | kOcclusion | kFaded,
+	};
+}

plugin/lib/commonlibf4/include/RE/A/ADDON_DATA.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	class ADDON_DATA
+	{
+	public:
+		// members
+		std::uint16_t masterParticleCap;  // 0
+		std::int8_t   flags;              // 2
+	};
+	static_assert(sizeof(ADDON_DATA) == 0x4);
+}

plugin/lib/commonlibf4/include/RE/A/AIDATA_GAME.h

@@ -0,0 +1,20 @@
+#pragma once
+
+namespace RE
+{
+	class AIDATA_GAME
+	{
+	public:
+		// members
+		std::uint32_t aggression: 2;      // 00:00
+		std::uint32_t confidence: 3;      // 00:02
+		std::uint32_t energy: 8;          // 00:05
+		std::uint32_t morality: 2;        // 00:13
+		std::uint32_t unused: 3;          // 00:15
+		std::uint32_t assistance: 2;      // 00:18
+		std::uint32_t useAggroRadius: 1;  // 00:20
+		std::uint16_t aggroRadius[3];     // 04
+		std::uint32_t noSlowApproach: 1;  // 0A:00
+	};
+	static_assert(sizeof(AIDATA_GAME) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/A/AIFormulas.h

@@ -0,0 +1,21 @@
+#pragma once
+
+namespace RE
+{
+	namespace AIFormulas
+	{
+		inline float GetBarterValue(float a_baseValue, float a_charisma, bool a_selling, TESObjectREFR* a_refTarget)
+		{
+			using func_t = decltype(&AIFormulas::GetBarterValue);
+			static REL::Relocation<func_t> func{ ID::AIFormulas::GetBarterValue };
+			return func(a_baseValue, a_charisma, a_selling, a_refTarget);
+		}
+
+		inline std::uint32_t ComputePickpocketSuccess(float a_thiefSkill, float a_targetSkill, std::int32_t a_valueStolen, float a_weightStolen, Actor* a_thief, Actor* a_target, TESForm* a_itemPickpocketing, bool a_placingItem)
+		{
+			using func_t = decltype(&AIFormulas::ComputePickpocketSuccess);
+			static REL::Relocation<func_t> func{ ID::AIFormulas::ComputePickpocketSuccess };
+			return func(a_thiefSkill, a_targetSkill, a_valueStolen, a_weightStolen, a_thief, a_target, a_itemPickpocketing, a_placingItem);
+		}
+	}
+}

plugin/lib/commonlibf4/include/RE/A/AIProcess.h

@@ -0,0 +1,219 @@
+#pragma once
+
+#include "RE/A/AITimer.h"
+#include "RE/A/ActorPackage.h"
+#include "RE/B/BGSEquipIndex.h"
+#include "RE/B/BGSObjectInstance.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSimpleList.h"
+#include "RE/D/DEFAULT_OBJECT.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	enum class COMMAND_TYPE;
+	enum class DIALOGUE_SUBTYPE;
+	enum class DIALOGUE_TYPE;
+	enum class WEAPON_CULL_TYPE;
+	class CachedValues;
+	class HighProcessData;
+	class MiddleHighProcessData;
+	class MiddleLowProcessData;
+	class ObjectstoAcquire;
+
+	class AIProcess
+	{
+	public:
+		enum class FADE_STATE
+		{
+			kNormal = 0x0,
+			kIn = 0x1,
+			kOut = 0x2,
+			kTeleportIn = 0x3,
+			kTeleportOut = 0x4,
+			kOutDisable = 0x5,
+			kOutDelete = 0x6
+		};
+
+		enum class HEAD_TRACK_TYPE
+		{
+			kDefault = 0x0,
+			kAction = 0x1,
+			kCombat = 0x2,
+			kDialog = 0x3,
+			kScript = 0x4,
+			kProcedure = 0x5,
+			kTotal = 0x6
+		};
+
+		[[nodiscard]] TESAmmo* GetCurrentAmmo(BGSEquipIndex a_equipIndex) const
+		{
+			using func_t = decltype(&AIProcess::GetCurrentAmmo);
+			static REL::Relocation<func_t> func{ ID::AIProcess::GetCurrentAmmo };
+			return func(this, a_equipIndex);
+		}
+
+		COMMAND_TYPE GetCommandType()
+		{
+			using func_t = decltype(&AIProcess::GetCommandType);
+			static REL::Relocation<func_t> func{ ID::AIProcess::GetCommandType };
+			return func(this);
+		}
+
+		[[nodiscard]] ObjectRefHandle GetOccupiedFurniture()
+		{
+			using func_t = decltype(&AIProcess::GetOccupiedFurniture);
+			static REL::Relocation<func_t> func{ ID::AIProcess::GetOccupiedFurniture };
+			return func(this);
+		}
+
+		bool IsWeaponSubgraphFinishedLoading(const Actor& a_actor)
+		{
+			using func_t = decltype(&AIProcess::IsWeaponSubgraphFinishedLoading);
+			static REL::Relocation<func_t> func{ ID::AIProcess::IsWeaponSubgraphFinishedLoading };
+			return func(this, a_actor);
+		}
+
+		void KnockExplosion(Actor* a_actor, const NiPoint3& a_location, float a_magnitude)
+		{
+			using func_t = decltype(&AIProcess::KnockExplosion);
+			static REL::Relocation<func_t> func{ ID::AIProcess::KnockExplosion };
+			return func(this, a_actor, a_location, a_magnitude);
+		}
+
+		bool PlayIdle(Actor& a_actor, TESIdleForm* a_idle, TESObjectREFR* a_target)
+		{
+			return SetupSpecialIdle(a_actor, DEFAULT_OBJECT::kActionIdle, a_idle, true, a_target);
+		}
+
+		bool ProcessGreet(Actor* a_actor, DIALOGUE_TYPE a_type, DIALOGUE_SUBTYPE a_subType, TESObjectREFR* a_target, BGSDialogueBranch* a_branch, bool a_forceSub, bool a_stop, bool a_que, bool a_sayCallback)
+		{
+			using func_t = decltype(&AIProcess::ProcessGreet);
+			static REL::Relocation<func_t> func{ ID::AIProcess::ProcessGreet };
+			return func(this, a_actor, a_type, a_subType, a_target, a_branch, a_forceSub, a_stop, a_que, a_sayCallback);
+		}
+
+		bool RequestLoadAnimationsForWeaponChange(Actor& a_actor)
+		{
+			using func_t = decltype(&AIProcess::RequestLoadAnimationsForWeaponChange);
+			static REL::Relocation<func_t> func{ ID::AIProcess::RequestLoadAnimationsForWeaponChange };
+			return func(this, a_actor);
+		}
+
+		void SetActorsDetectionEvent(Actor* a_actor, const NiPoint3& a_location, std::int32_t a_soundLevel, TESObjectREFR* a_refr)
+		{
+			using func_t = decltype(&AIProcess::SetActorsDetectionEvent);
+			static REL::Relocation<func_t> func{ ID::AIProcess::SetActorsDetectionEvent };
+			return func(this, a_actor, a_location, a_soundLevel, a_refr);
+		}
+
+		void SetCurrentAmmo(BGSEquipIndex a_equipIndex, TESAmmo* a_ammo)
+		{
+			using func_t = decltype(&AIProcess::SetCurrentAmmo);
+			static REL::Relocation<func_t> func{ ID::AIProcess::SetCurrentAmmo };
+			return func(this, a_equipIndex, a_ammo);
+		}
+
+		void SetCommandType(COMMAND_TYPE a_type)
+		{
+			using func_t = decltype(&AIProcess::SetCommandType);
+			static REL::Relocation<func_t> func{ ID::AIProcess::SetCommandType };
+			return func(this, a_type);
+		}
+
+		void SetEquippedItem(Actor* a_actor, const BGSObjectInstance& a_instance, const BGSEquipSlot* a_slot)
+		{
+			using func_t = decltype(&AIProcess::SetEquippedItem);
+			static REL::Relocation<func_t> func{ ID::AIProcess::SetEquippedItem };
+			return func(this, a_actor, a_instance, a_slot);
+		}
+
+		bool SetupSpecialIdle(Actor& a_actor, DEFAULT_OBJECT a_defaultObject, TESIdleForm* a_idle, bool a_testConditions, TESObjectREFR* a_targetOverride)
+		{
+			using func_t = decltype(&AIProcess::SetupSpecialIdle);
+			static REL::Relocation<func_t> func{ ID::AIProcess::SetupSpecialIdle };
+			return func(this, a_actor, a_defaultObject, a_idle, a_testConditions, a_targetOverride);
+		}
+
+		bool SetWeaponBonesCulled(const Actor& a_actor, bool a_stateToSet, WEAPON_CULL_TYPE a_weaponCullType)
+		{
+			using func_t = decltype(&AIProcess::SetWeaponBonesCulled);
+			static REL::Relocation<func_t> func{ ID::AIProcess::SetWeaponBonesCulled };
+			return func(this, a_actor, a_stateToSet, a_weaponCullType);
+		}
+
+		void StopCurrentIdle(Actor* a_actor, bool a_instant, bool a_killFlavor)
+		{
+			using func_t = decltype(&AIProcess::StopCurrentIdle);
+			static REL::Relocation<func_t> func{ ID::AIProcess::StopCurrentIdle };
+			return func(this, a_actor, a_instant, a_killFlavor);
+		}
+
+		void SetRunOncePackage(TESPackage* a_package, Actor* a_actor)
+		{
+			using func_t = decltype(&AIProcess::SetRunOncePackage);
+			static REL::Relocation<func_t> func{ ID::AIProcess::SetRunOncePackage };
+			return func(this, a_package, a_actor);
+		}
+
+		void AddToProcedureIndexRunning(Actor* a_actor, std::int32_t a_number)
+		{
+			using func_t = decltype(&AIProcess::AddToProcedureIndexRunning);
+			static REL::Relocation<func_t> func{ ID::AIProcess::AddToProcedureIndexRunning };
+			return func(this, a_actor, a_number);
+		}
+
+		void ComputeLastTimeProcessed()
+		{
+			using func_t = decltype(&AIProcess::ComputeLastTimeProcessed);
+			static REL::Relocation<func_t> func{ ID::AIProcess::ComputeLastTimeProcessed };
+			return func(this);
+		}
+
+		float GetActorLightLevel()
+		{
+			using func_t = decltype(&AIProcess::GetActorLightLevel);
+			static REL::Relocation<func_t> func{ ID::AIProcess::GetActorLightLevel };
+			return func(this);
+		}
+
+		// members
+		MiddleLowProcessData*           middleLow;                   // 00
+		MiddleHighProcessData*          middleHigh;                  // 08
+		HighProcessData*                high;                        // 10
+		ActorPackage                    currentPackage;              // 18
+		float                           hourLastProcessed;           // 48
+		float                           timeAdjustmentsMade;         // 4C
+		std::uint32_t                   dateLastProcessed;           // 50
+		CachedValues*                   cachedValues;                // 58
+		std::int32_t                    numberItemsActivate;         // 60
+		BSSimpleList<ObjectstoAcquire*> objectList;                  // 68
+		BSSimpleList<TESObjectREFR*>    genericLocationsList;        // 78
+		ObjectstoAcquire*               acquireObject;               // 88
+		ObjectstoAcquire*               savedAcquireObject;          // 90
+		float                           essentialDownTimer;          // 98
+		float                           deathTime;                   // 9C
+		float                           trackedDamage;               // A0
+		TESBoundObject*                 itemBeingUsed;               // A8
+		AITimer                         combatDelayTimer;            // B0
+		ObjectRefHandle                 followTarget;                // B8
+		ObjectRefHandle                 target;                      // BC
+		ObjectRefHandle                 genericLocation;             // C0
+		ObjectRefHandle                 genericSecondLocation;       // C4
+		BGSListForm*                    targetFormList;              // C8
+		std::uint32_t                   currentSpeakingTopicID;      // D0
+		ObjectRefHandle                 patrolLocation;              // D4
+		ObjectRefHandle                 idleTarget;                  // D8
+		std::int16_t                    formListNumb;                // DC
+		std::uint8_t                    lowProcessFlags;             // DE
+		std::uint8_t                    processLevel;                // DF
+		bool                            skippedTimeStampForPathing;  // E0
+		bool                            ignoringCombat;              // E1
+		bool                            endAlarmOnActor;             // E2
+		bool                            escortingPlayer;             // E3
+		bool                            updateEditorDeadModel;       // E4
+		bool                            editorDeadActive;            // E5
+		bool                            initializingPosition;        // E6
+	};
+	static_assert(sizeof(AIProcess) == 0xE8);
+}

plugin/lib/commonlibf4/include/RE/A/AITimeStamp.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	class AITimeStamp
+	{
+	public:
+		// members
+		float timeStamp;  // 0
+	};
+	static_assert(sizeof(AITimeStamp) == 0x4);
+}

plugin/lib/commonlibf4/include/RE/A/AITimer.h

@@ -0,0 +1,19 @@
+#pragma once
+
+namespace RE
+{
+	class AITimer
+	{
+	public:
+		static float fTimer()
+		{
+			static REL::Relocation<float*> singleton{ ID::AITimer::fTimer };
+			return *singleton;
+		}
+
+		// members
+		float startTime;   // 00
+		float targetTime;  // 04
+	};
+	static_assert(sizeof(AITimer) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/A/AMMO_DATA.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	class AMMO_DATA
+	{
+	public:
+		// members
+		BGSProjectile* projectile;  // 00
+		std::uint32_t  health;      // 08
+		std::int8_t    flags;       // 0C
+		float          damage;      // 10
+	};
+	static_assert(sizeof(AMMO_DATA) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/A/ActionInput.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class __declspec(novtable) ActionInput
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActionInput };
+		static constexpr auto VTABLE{ VTABLE::ActionInput };
+
+		enum class ACTIONPRIORITY
+		{
+			kImperative = 0x0,
+			kQueue = 0x1,
+			kTry = 0x2
+		};
+
+		class Data
+		{
+		public:
+			union
+			{
+				float         f;
+				std::int32_t  i;
+				std::uint32_t ui;
+			};  //00
+		};
+
+		virtual ~ActionInput();  // 00
+
+		// members
+		NiPointer<TESObjectREFR>                     ref;         // 08
+		NiPointer<TESObjectREFR>                     targetRef;   // 10
+		BGSAction*                                   action;      // 18
+		REX::TEnumSet<ACTIONPRIORITY, std::uint32_t> priority;    // 20
+		Data                                         ActionData;  // 24
+	};
+	static_assert(sizeof(ActionInput) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/A/ActionOutput.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class TESIdleForm;
+
+	class ActionOutput
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActionOutput };
+
+		enum class ACTION_RESULTS : std::uint32_t
+		{
+			kNotAllowed = 0xFFFFFFFF
+		};
+
+		// members
+		BSFixedString      animEvent;        // 00
+		BSFixedString      targetAnimEvent;  // 08
+		std::int32_t       result;           // 10
+		TESIdleForm*       sequence;         // 18
+		const TESIdleForm* animObjIdle;      // 20
+		std::uint32_t      sequenceIndex;    // 28;
+	};
+	static_assert(sizeof(ActionOutput) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/A/ActionPoints.h

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace RE
+{
+	class ActionPoints
+	{
+	public:
+		enum class Action
+		{
+			kUnarmed = 0x0,
+			kOneHandMelee = 0x1,
+			kTwoHandMelee = 0x2,
+			kMagic = 0x3,
+			kRanged = 0x4,
+			kReload = 0x5,
+			kSwitchWeapon = 0x6,
+			kToggleWeaponDrawn = 0x7,
+			kHeal = 0x8,
+			kPlayerVATSDeath = 0x9,
+			kPlayerDialogue = 0xA,
+			kSightedEnter = 0xB,
+
+			kTotal = 0xC
+		};
+	};
+	static_assert(std::is_empty_v<ActionPoints>);
+}

plugin/lib/commonlibf4/include/RE/A/ActiveEffect.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "RE/A/ActiveEffectReferenceEffectController.h"
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSimpleList.h"
+#include "RE/B/BSSoundHandle.h"
+#include "RE/E/ENUM_FORM_ID.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class MagicTarget;
+	class NiNode;
+	class ReferenceEffect;
+
+	namespace MagicSystem
+	{
+		enum class CastingSource : std::int32_t;
+	}
+
+	class __declspec(novtable) ActiveEffect :
+		public BSIntrusiveRefCounted
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActiveEffect };
+		static constexpr auto VTABLE{ VTABLE::ActiveEffect };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kActiveEffect };
+
+		enum class Flags : std::uint32_t
+		{
+			kNone = 0,
+			kNoHitShader = 1U << 1,
+			kNoHitEffectArt = 1U << 2,
+			kNoInitialFlare = 1U << 4,
+			kApplyingHitEffects = 1U << 5,
+			kApplyingSounds = 1U << 6,
+			kHasConditions = 1U << 7,
+			kRecover = 1U << 9,
+			kDualCasted = 1U << 12,
+			kInactive = 1U << 15,
+			kAppliedEffects = 1U << 16,
+			kRemovedEffects = 1U << 17,
+			kDispelled = 1U << 18,
+			kWornOff = 1U << 31
+		};
+
+		enum class ConditionStatus : std::uint32_t
+		{
+			kNotAvailable = 0xFFFFFFFF,
+			kFalse = 0,
+			kTrue = 1
+		};
+
+		virtual ~ActiveEffect();
+
+		bool CheckDisplacementSpellOnTarget()
+		{
+			using func_t = decltype(&ActiveEffect::CheckDisplacementSpellOnTarget);
+			static REL::Relocation<func_t> func{ ID::ActiveEffect::CheckDisplacementSpellOnTarget };
+			return func(this);
+		}
+
+		// members
+		ActiveEffectReferenceEffectController hitEffectController;  // 0C
+		BSSoundHandle                         persistentSound;      // 30
+		ActorHandle                           caster;               // 38
+		NiPointer<NiNode>                     sourceNode;           // 40
+		MagicItem*                            spell;                // 48
+		EffectItem*                           effect;               // 50
+		MagicTarget*                          target;               // 58
+		TESBoundObject*                       source;               // 60
+		BSSimpleList<ReferenceEffect*>*       hitEffects;           // 68
+		MagicItem*                            displacementSpell;    // 70
+		float                                 elapsedSeconds;       // 74
+		float                                 duration;             // 78
+		float                                 magnitude;            // 7C
+		REX::TEnumSet<Flags, std::uint32_t>   flags;                // 80
+		ConditionStatus                       conditionStatus;      // 84
+		std::uint16_t                         uniqueID;             // 8C
+		MagicSystem::CastingSource            castingSource;        // 90
+	};
+	static_assert(sizeof(ActiveEffect) == 0x98);
+}

plugin/lib/commonlibf4/include/RE/A/ActiveEffectList.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTSmartPointer.h"
+
+namespace RE
+{
+	class ActiveEffectList
+	{
+	public:
+		// members
+		BSTArray<BSTSmartPointer<ActiveEffect>> data;       // 00
+		std::int8_t                             iterating;  // 18
+	};
+	static_assert(sizeof(ActiveEffectList) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/A/ActiveEffectReferenceEffectController.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/R/ReferenceEffectController.h"
+
+namespace RE
+{
+	class __declspec(novtable) ActiveEffectReferenceEffectController :
+		public ReferenceEffectController  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActiveEffectReferenceEffectController };
+		static constexpr auto VTABLE{ VTABLE::ActiveEffectReferenceEffectController };
+
+		// override (ReferenceEffectController)
+		void             HandleEvent(const BSFixedString& a_event) override;                 // 01 - return { effect->HandleEvent(a_event); }
+		float            GetElapsedTime() override;                                          // 02 - return { effect->elapsedSeconds; }
+		float            GetScale() override;                                                // 03
+		void             SwitchAttachedRoot(NiNode* a_root, NiNode* a_attachRoot) override;  // 04 - return { effect->SwitchAttachedRoot(a_root, a_attachRoot); }
+		const NiPoint3&  GetSourcePosition() override;                                       // 05
+		bool             GetUseSourcePosition() override;                                    // 06
+		bool             GetNoInitialFlare() override;                                       // 07
+		bool             GetEffectPersists() override;                                       // 08
+		bool             GetGoryVisuals() override;                                          // 09
+		void             RemoveHitEffect(ReferenceEffect* a_refEffect) override;             // 0A
+		TESObjectREFR*   GetTargetReference() override;                                      // 0B
+		BGSArtObject*    GetHitEffectArt() override;                                         // 0C
+		TESEffectShader* GetHitEffectShader() override;                                      // 0D
+		bool             GetManagerHandlesSaveLoad() override;                               // 0E - { return false; }
+		bool             EffectShouldFaceTarget() override;                                  // 17
+		TESObjectREFR*   GetFacingTarget() override;                                         // 18
+		void             SetWindPoint(const NiPoint3& a_point) override;                     // 1E - { windPoint = a_point; }
+		const NiPoint3&  GetWindPoint() override;                                            // 1F - { return windPoint; }
+		bool             GetAllowNo3D() override;                                            // 20
+		void             SaveGame(BGSSaveGameBuffer* a_buf) override;                        // 21
+		void             LoadGame(BGSLoadGameBuffer* a_buf) override;                        // 22
+
+		// members
+		ActiveEffect*   effect;     // 08
+		NiPoint3        windPoint;  // 10
+		ObjectRefHandle target;     // 18
+	};
+	static_assert(sizeof(ActiveEffectReferenceEffectController) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/A/Actor.h

@@ -0,0 +1,674 @@
+#pragma once
+
+#include "RE/A/ACTOR_VISIBILITY_MASK.h"
+#include "RE/A/AIProcess.h"
+#include "RE/A/AITimeStamp.h"
+#include "RE/A/ActorState.h"
+#include "RE/A/ActorValueStorage.h"
+#include "RE/B/BGSEquipIndex.h"
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/C/CFilter.h"
+#include "RE/I/IPostAnimationChannelUpdateFunctor.h"
+#include "RE/M/MagicTarget.h"
+#include "RE/M/Modifiers.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/N/NiTFlags.h"
+#include "RE/O/ObjectEquipParams.h"
+#include "RE/S/SEX.h"
+#include "RE/T/TESObjectREFR.h"
+
+namespace RE
+{
+	enum class ACTOR_CRITICAL_STAGE;
+	enum class ACTOR_LIFE_STATE;
+	enum class ACTOR_LOS_LOCATION;
+	enum class GUN_STATE;
+	enum class PACKAGE_OBJECT_TYPE;
+	enum class POWER_ATTACK_TYPE;
+
+	template <class>
+	class BSPointerHandleSmartPointer;
+
+	class ActorCPMEvent;
+	class ActorMagicCaster;
+	class ActorMotionFeedbackData;
+	class ActorMotionFeedbackOutput;
+	class ActorMover;
+	class bhkCharacterController;
+	class bhkCharacterMoveFinishEvent;
+	class bhkCharacterStateChangeEvent;
+	class bhkNonSupportContactEvent;
+	class BSMovementDataChangedEvent;
+	class BSSubGraphActivationUpdate;
+	class BSTransformDeltaEvent;
+	class CastPowerItem;
+	class CombatController;
+	class CombatGroup;
+	class DetectionData;
+	class HitData;
+	class MovementControllerNPC;
+	class MovementMessageActorCollision;
+	class MovementMessageNewPath;
+	class MovementMessageUpdateRequestImmediate;
+	class PackageLocation;
+	class PerkEntryVisitor;
+	class Perks;
+
+	namespace MagicSystem
+	{
+		enum class CannotCastReason;
+	}
+
+	namespace PerkValueEvents
+	{
+		class PerkEntryUpdatedEvent;
+		class PerkValueChangedEvent;
+	}
+
+	class __declspec(novtable) Actor :
+		public TESObjectREFR,                                           // 000
+		public MagicTarget,                                             // 110
+		public ActorState,                                              // 128
+		public BSTEventSink<BSMovementDataChangedEvent>,                // 138
+		public BSTEventSink<BSTransformDeltaEvent>,                     // 140
+		public BSTEventSink<BSSubGraphActivationUpdate>,                // 148
+		public BSTEventSink<bhkCharacterMoveFinishEvent>,               // 150
+		public BSTEventSink<bhkNonSupportContactEvent>,                 // 158
+		public BSTEventSink<bhkCharacterStateChangeEvent>,              // 160
+		public IPostAnimationChannelUpdateFunctor,                      // 168
+		public BSTEventSource<MovementMessageUpdateRequestImmediate>,   // 170
+		public BSTEventSource<PerkValueEvents::PerkValueChangedEvent>,  // 1C8
+		public BSTEventSource<PerkValueEvents::PerkEntryUpdatedEvent>,  // 220
+		public BSTEventSource<ActorCPMEvent>                            // 278
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::Actor };
+		static constexpr auto VTABLE{ VTABLE::Actor };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kACHR };
+
+		enum class BOOL_FLAGS
+		{
+			kNone = 0,
+			kScenePackage = 1 << 0,
+			kIsAMount = 1 << 1,
+			kIsMountPointClear = 1 << 2,
+			kIsGettingOnOffMount = 1 << 3,
+			kInRandomScene = 1 << 4,
+			kNoBleedoutRecovery = 1 << 5,
+			kInBleedoutAnimation = 1 << 6,
+			kCanDoFavor = 1 << 7,
+			kShouldAnimGraphUpdate = 1 << 8,
+			kCanSpeakToEssentialDown = 1 << 9,
+			kBribedByPlayer = 1 << 10,
+			kAngryWithPlayer = 1 << 11,
+			kIsTresspassing = 1 << 12,
+			kCanSpeak = 1 << 13,
+			kIsInKillMove = 1 << 14,
+			kAttackOnSight = 1 << 15,
+			kIsCommandedActor = 1 << 16,
+			kForceOneAnimGraphUpdate = 1 << 17,
+			kEssential = 1 << 18,
+			kProtected = 1 << 19,
+			kAttackingDisabled = 1 << 20,
+			kCastingDisabled = 1 << 21,
+			kSceneHeadtrackRotation = 1 << 22,
+			kForceIncMinBoneUpdate = 1 << 23,
+			kCrimeSearch = 1 << 24,
+			kMovingIntoLoadedArea = 1 << 25,
+			kDoNotShowOnStealthMeter = 1 << 26,
+			kMovementBlocked = 1 << 27,
+			kAllowInstantFurniturePopInPlayerCell = 1 << 28,
+			kForceAnimGraphUpdate = 1 << 29,
+			kCheckAddEffectDualCast = 1 << 30,
+			kUnderwater = 1 << 31,
+		};
+
+		// add
+		virtual void                 PlayPickUpSound(TESBoundObject* a_boundObj, bool a_pickUp, bool a_use);                                                                                                             // 0C6
+		virtual float                GetHeading() const { return data.angle.z; }                                                                                                                                         // 0C7
+		virtual void                 SetAvoidanceDisabled([[maybe_unused]] bool a_tf) { return; }                                                                                                                        // 0C8
+		virtual void                 DrawWeaponMagicHands(bool a_draw);                                                                                                                                                  // 0C9
+		virtual void                 SetPosition(const NiPoint3& a_pos, bool a_updateCharController);                                                                                                                    // 0CA
+		virtual void                 KillDying();                                                                                                                                                                        // 0CB
+		virtual void                 Resurrect(bool a_resetInventory, bool a_attach3D);                                                                                                                                  // 0CC
+		virtual bool                 PutActorInChairBedQuick(TESObjectREFR* a_furniture, std::uint32_t a_index);                                                                                                         // 0CD
+		virtual bool                 PutActorOnMountQuick();                                                                                                                                                             // 0CE
+		virtual void                 Update(float a_delta);                                                                                                                                                              // 0CF
+		virtual void                 UpdateNoAI(float);                                                                                                                                                                  // 0D0
+		virtual void                 UpdateMotionDrivenState();                                                                                                                                                          // 0D1
+		virtual void                 UpdateCharacterControllerSimulationSettings(bhkCharacterController& a_charController);                                                                                              // 0D2
+		virtual void                 PotentiallyFixRagdollState();                                                                                                                                                       // 0D3
+		virtual void                 UpdateNonRenderSafe(float);                                                                                                                                                         // 0D4
+		virtual bool                 ShouldHandleEquipNow() const;                                                                                                                                                       // 0D5
+		virtual void                 SetCrimeGoldValue(TESFaction* a_faction, bool a_violent, std::uint32_t a_value);                                                                                                    // 0D6
+		virtual std::uint32_t        ModCrimeGoldValue(TESFaction* a_faction, bool a_violent, std::int32_t a_value);                                                                                                     // 0D7
+		virtual void                 RemoveCrimeGoldValue(TESFaction* a_faction, bool a_violent, std::int32_t a_value);                                                                                                  // 0D8
+		virtual std::uint32_t        GetCrimeGoldValue(const TESFaction* a_faction) const;                                                                                                                               // 0D9
+		virtual void                 GoToPrison([[maybe_unused]] TESFaction* a_faction, [[maybe_unused]] bool a_removeItems, [[maybe_unused]] bool a_realJail) { return; }                                               // 0DA
+		virtual void                 ServePrisonTime() { return; }                                                                                                                                                       // 0DB
+		virtual void                 PayFine([[maybe_unused]] TESFaction* a_faction, [[maybe_unused]] bool a_movetoMarker, [[maybe_unused]] bool a_removeStolenItems) { return; }                                        // 0DC
+		virtual float                GetCurrentEyeLevel() const;                                                                                                                                                         // 0DD
+		virtual void                 SetInDialoguewithPlayer(bool a_flag);                                                                                                                                               // 0DE
+		virtual bool                 GetCannibal() { return false; }                                                                                                                                                     // 0DF
+		virtual void                 SetCannibal(bool) { return; }                                                                                                                                                       // 0E0
+		virtual bool                 GetVampireFeed() { return false; }                                                                                                                                                  // 0E1
+		virtual void                 SetVampireFeed(bool) { return; }                                                                                                                                                    // 0E2
+		virtual void                 InitiateVampireFeedPackage(Actor* a_target, TESObjectREFR* a_furniture);                                                                                                            // 0E3
+		virtual void                 InitiateCannibalPackage(Actor* a_target);                                                                                                                                           // 0E4
+		virtual float                GetEyeHeading() const;                                                                                                                                                              // 0E5
+		virtual void                 GetEyeAngles(float& a_eyeHeading, float& a_eyeLooking) const;                                                                                                                       // 0E6
+		virtual void                 GetEyeVector(NiPoint3& a_origin, NiPoint3& a_direction, bool a_includeCameraOffset) const;                                                                                          // 0E7
+		virtual void                 SetRefraction(bool a_enable, float a_refractionPower);                                                                                                                              // 0E8
+		virtual float                GetAcrobatics() const { return 1.0F; }                                                                                                                                              // 0E9
+		virtual bool                 Get3DUpdateFlag(RESET_3D_FLAGS a_flag) const;                                                                                                                                       // 0EA
+		virtual ObjectRefHandle      DropObject(const BGSObjectInstance& a_object, BSTSmallArray<std::uint32_t, 4>* a_stackData, std::int32_t a_number, const NiPoint3* a_point, const NiPoint3* a_rotate);              // 0EB
+		virtual void                 PickUpObject(TESObjectREFR* a_objREFR, std::int32_t a_count, bool a_playPickUpSounds);                                                                                              // 0EC
+		virtual void                 AttachArrow(const BSTSmartPointer<BipedAnim>& a_biped, BGSEquipIndex a_equipIndex);                                                                                                 // 0ED
+		virtual void                 DetachArrow(const BSTSmartPointer<BipedAnim>& a_biped, BGSEquipIndex a_equipIndex);                                                                                                 // 0EE
+		virtual bool                 ReloadWeapon(const BGSObjectInstanceT<TESObjectWEAP>& a_weapon, BGSEquipIndex a_equipIndex);                                                                                        // 0EF
+		virtual std::uint32_t        UseAmmo(const BGSObjectInstanceT<TESObjectWEAP>& a_weapon, BGSEquipIndex a_equipIndex, std::uint32_t a_shotCount);                                                                  // 0F0
+		virtual bool                 CalculateCachedOwnerIsInCombatantFaction() const;                                                                                                                                   // 0F1
+		virtual CombatGroup*         GetCombatGroup() const;                                                                                                                                                             // 0F2
+		virtual void                 SetCombatGroup(CombatGroup* a_group);                                                                                                                                               // 0F3
+		virtual bool                 CheckValidTarget(TESObjectREFR& a_ref) const;                                                                                                                                       // 0F4
+		virtual bool                 InitiateDialogue(Actor* a_target, PackageLocation* a_packLoc, PackageLocation* a_packSecondLoc);                                                                                    // 0F5
+		virtual void                 EndDialogue();                                                                                                                                                                      // 0F6
+		virtual Actor*               SetUpTalkingActivatorActor(Actor* a_target, Actor*& a_talkingactivator);                                                                                                            // 0F7
+		virtual void                 InitiateFlee(TESObjectREFR* a_fleeRef, bool a_runonce, bool a_knows, bool a_combatMode, TESObjectCELL* a_cell, TESObjectREFR* a_ref, float a_fleeFromDist, float a_fleeToDist);     // 0F8
+		virtual void                 InitiateGetUpPackage();                                                                                                                                                             // 0F9
+		virtual void                 PutCreatedPackage(TESPackage* a_pack, bool a_tempPack, bool a_isACreatedPackage, bool a_allowFromFurniture);                                                                        // 0FA
+		virtual void                 UpdateAlpha();                                                                                                                                                                      // 0FB
+		virtual void                 SetAlpha(float a_newAlpha);                                                                                                                                                         // 0FC
+		virtual float                GetAlpha();                                                                                                                                                                         // 0FD
+		virtual bool                 IsInCombat() const;                                                                                                                                                                 // 0FE
+		virtual void                 UpdateCombat();                                                                                                                                                                     // 0FF
+		virtual void                 StopCombat();                                                                                                                                                                       // 100
+		virtual bool                 GetUsesAttackPercents() { return false; }                                                                                                                                           // 101
+		virtual std::uint8_t         GetPowerAttackPercent(POWER_ATTACK_TYPE) { return 0; }                                                                                                                              // 102
+		virtual void                 WeaponSwingCallBack(BGSEquipIndex a_equipIndex);                                                                                                                                    // 103
+		virtual void                 SetActorStartingPosition();                                                                                                                                                         // 104
+		virtual void                 SetLifeState(ACTOR_LIFE_STATE a_lifeState);                                                                                                                                         // 105
+		virtual bool                 HasBeenAttacked();                                                                                                                                                                  // 106
+		virtual void                 SetBeenAttacked(bool a_flag);                                                                                                                                                       // 107
+		virtual void                 UseSkill(ActorValueInfo*, float, TESForm*) { return; }                                                                                                                              // 108
+		virtual bool                 IsAtPoint(const NiPoint3& a_point, float a_radius, bool a_expandRadius, bool a_alwaysTestHeight);                                                                                   // 109
+		virtual bool                 IsInFaction(const TESFaction* a_faction) const;                                                                                                                                     // 10A
+		virtual bool                 HasPerkEntries(std::uint8_t a_entryPoint) const;                                                                                                                                    // 10B
+		virtual void                 ForEachPerkEntry(std::uint8_t a_entryPoint, PerkEntryVisitor& a_visitor) const;                                                                                                     // 10C
+		virtual void                 ApplyPerksFromBase();                                                                                                                                                               // 10D
+		virtual void                 StartPowerAttackCoolDown() { return; }                                                                                                                                              // 10E
+		virtual bool                 IsPowerAttackCoolingDown() const { return false; }                                                                                                                                  // 10F
+		virtual void                 HandleHealthDamage(Actor* a_attacker, float a_damage);                                                                                                                              // 110
+		virtual bool                 QSpeakingDone() const;                                                                                                                                                              // 111
+		virtual void                 SetSpeakingDone(bool a_done);                                                                                                                                                       // 112
+		virtual NiPoint3             CalculateLOSLocation(ACTOR_LOS_LOCATION a_location) const;                                                                                                                          // 113
+		virtual void                 CreateMovementController();                                                                                                                                                         // 114
+		virtual bool                 ShouldPivotToFaceCamera() const { return false; }                                                                                                                                   // 115
+		virtual BGSKeyword*          GetSpeakingAnimArchType() { return speakingAnimArchType; }                                                                                                                          // 116
+		virtual void                 KillImpl(Actor* a_attacker, float a_damage, bool a_sendEvent, bool a_ragdollInstant);                                                                                               // 117
+		virtual void                 DoReparentWeapon(const TESObjectWEAP* a_weapon, BGSEquipIndex a_equipIndex, bool a_weaponDrawn);                                                                                    // 118
+		virtual bool                 DrinkPotion(AlchemyItem* a_potion, std::uint32_t a_stackID);                                                                                                                        // 119
+		virtual bool                 CheckCast(MagicItem* a_spell, bool a_dualCast, MagicSystem::CannotCastReason* a_reason);                                                                                            // 11A
+		virtual void                 CheckTempModifiers() { return; }                                                                                                                                                    // 11B
+		virtual void                 SetLastRiddenMount([[maybe_unused]] ActorHandle a_mount) { return; }                                                                                                                // 11C
+		virtual ActorHandle          QLastRiddenMount() const;                                                                                                                                                           // 11D
+		virtual bool                 CalculateCachedOwnerIsUndead() const;                                                                                                                                               // 11E
+		virtual bool                 CalculateCachedOwnerIsNPC() const;                                                                                                                                                  // 11F
+		virtual bool                 SetSneaking(bool a_sneaking);                                                                                                                                                       // 120
+		virtual void                 ResetHavokPhysics();                                                                                                                                                                // 121
+		virtual bool                 ShouldDoCharacterUpdate() const { return true; }                                                                                                                                    // 122
+		virtual bool                 GetAnimationCanBeInterpolated() const;                                                                                                                                              // 123
+		virtual const BSFixedString& GetResponseString() const;                                                                                                                                                          // 124
+		virtual void                 ModifyMovementData(float a_delta, NiPoint3& a_moveDelta, NiPoint3& a_angleDelta);                                                                                                   // 125
+		virtual void                 UpdateCombatControllerSettings();                                                                                                                                                   // 126
+		virtual void                 UpdateFadeSettings(bhkCharacterController* a_charController);                                                                                                                       // 127
+		virtual bool                 ComputeMotionFeedbackSpeedAndDirection(const ActorMotionFeedbackData& a_data, float a_delta, ActorMotionFeedbackOutput& a_retData);                                                 // 128
+		virtual bool                 UpdateFeedbackGraphSpeedAndDirection(const ActorMotionFeedbackOutput& a_data);                                                                                                      // 129
+		virtual void                 UpdateActor3DPosition();                                                                                                                                                            // 12A
+		virtual void                 PrecacheData();                                                                                                                                                                     // 12B
+		virtual void                 WornArmorChanged(const BGSObjectInstance& a_object);                                                                                                                                // 12C
+		virtual void                 ProcessTracking(float a_delta, NiAVObject* a_ob3D);                                                                                                                                 // 12D
+		virtual void                 CreateActorMover();                                                                                                                                                                 // 12E
+		virtual void                 DestroyActorMover();                                                                                                                                                                // 12F
+		virtual bool                 ShouldRespondToActorCollision(const MovementMessageActorCollision&, const BSPointerHandleSmartPointer<BSPointerHandleManagerInterface<Actor, HandleManager>>& a_otherActor) const;  // 130
+		virtual float                CheckClampDamageModifier(ActorValueInfo& a_info, float a_delta);                                                                                                                    // 131
+		virtual void                 ValidateNewPath([[maybe_unused]] const MovementMessageNewPath& a_newPathMessage) { return; }                                                                                        // 132
+
+		void AddPerk(BGSPerk* a_perk, std::uint8_t a_rank = 0)
+		{
+			using func_t = decltype(&Actor::AddPerk);
+			static REL::Relocation<func_t> func{ ID::Actor::AddPerk };
+			return func(this, a_perk, a_rank);
+		}
+
+		bool CanUseIdle(TESIdleForm* a_idle) const
+		{
+			using func_t = decltype(&Actor::CanUseIdle);
+			static REL::Relocation<func_t> func{ ID::Actor::CanUseIdle };
+			return func(this, a_idle);
+		}
+
+		void ClearAttackStates()
+		{
+			using func_t = decltype(&Actor::ClearAttackStates);
+			static REL::Relocation<func_t> func{ ID::Actor::ClearAttackStates };
+			return func(this);
+		}
+
+		void EndInterruptPackage(bool a_notRunOnceDialogue)
+		{
+			using func_t = decltype(&Actor::EndInterruptPackage);
+			static REL::Relocation<func_t> func{ ID::Actor::EndInterruptPackage };
+			return func(this, a_notRunOnceDialogue);
+		}
+
+		void ExitCover()
+		{
+			using func_t = decltype(&Actor::ExitCover);
+			static REL::Relocation<func_t> func{ ID::Actor::ExitCover };
+			return func(this);
+		}
+
+		void GetAimVector(NiPoint3& a_aimVector)
+		{
+			using func_t = decltype(&Actor::GetAimVector);
+			static REL::Relocation<func_t> func{ ID::Actor::GetAimVector };
+			return func(this, a_aimVector);
+		}
+
+		NiAVObject* GetClosestBone(NiPoint3 a_impactLocation, NiPoint3 a_movementDirection)
+		{
+			using func_t = decltype(&Actor::GetClosestBone);
+			static REL::Relocation<func_t> func{ ID::Actor::GetClosestBone };
+			return func(this, a_impactLocation, a_movementDirection);
+		}
+
+		CFilter GetCollisionFilter()
+		{
+			using func_t = decltype(&Actor::GetCollisionFilter);
+			static REL::Relocation<func_t> func{ ID::Actor::GetCollisionFilter };
+			return func(this);
+		}
+
+		TESCombatStyle* GetCombatStyle()
+		{
+			using func_t = decltype(&Actor::GetCombatStyle);
+			static REL::Relocation<func_t> func{ ID::Actor::GetCombatStyle };
+			return func(this);
+		}
+
+		[[nodiscard]] TESAmmo* GetCurrentAmmo(BGSEquipIndex a_equipIndex) const
+		{
+			return currentProcess ? currentProcess->GetCurrentAmmo(a_equipIndex) : nullptr;
+		}
+
+		std::uint32_t GetCurrentCollisionGroup()
+		{
+			using func_t = decltype(&Actor::GetCurrentCollisionGroup);
+			static REL::Relocation<func_t> func{ ID::Actor::GetCurrentCollisionGroup };
+			return func(this);
+		}
+
+		bool GetCurrentFireLocation(BGSEquipIndex a_index, NiPoint3& a_fireLocation)
+		{
+			using func_t = decltype(&Actor::GetCurrentFireLocation);
+			static REL::Relocation<func_t> func{ ID::Actor::GetCurrentFireLocation };
+			return func(this, a_index, a_fireLocation);
+		}
+
+		float GetDesiredSpeed()
+		{
+			using func_t = decltype(&Actor::GetDesiredSpeed);
+			static REL::Relocation<func_t> func{ ID::Actor::GetDesiredSpeed };
+			return func(this);
+		}
+
+		bool GetGhost()
+		{
+			using func_t = decltype(&Actor::GetGhost);
+			static REL::Relocation<func_t> func{ ID::Actor::GetGhost };
+			return func(this);
+		}
+
+		[[nodiscard]] bool GetHostileToActor(Actor* a_actor)
+		{
+			using func_t = decltype(&Actor::GetHostileToActor);
+			static REL::Relocation<func_t> func{ ID::Actor::GetHostileToActor };
+			return func(this, a_actor);
+		}
+
+		[[nodiscard]] ActorHandle GetMountHandle()
+		{
+			using func_t = decltype(&Actor::GetMountHandle);
+			static REL::Relocation<func_t> func{ ID::Actor::GetMountHandle };
+			return func(this);
+		}
+
+		[[nodiscard]] std::int16_t GetLevel()
+		{
+			using func_t = decltype(&Actor::GetLevel);
+			static REL::Relocation<func_t> func{ ID::Actor::GetLevel };
+			return func(this);
+		}
+
+		[[nodiscard]] TESNPC* GetNPC() const noexcept;
+
+		[[nodiscard]] std::uint8_t GetPerkRank(BGSPerk* a_perk)
+		{
+			using func_t = decltype(&Actor::GetPerkRank);
+			static REL::Relocation<func_t> func{ ID::Actor::GetPerkRank };
+			return func(this, a_perk);
+		}
+
+		SEX GetSex()
+		{
+			using func_t = decltype(&Actor::GetSex);
+			static REL::Relocation<func_t> func{ ID::Actor::GetSex };
+			return func(this);
+		}
+
+		void HandleDefaultAnimationSwitch()
+		{
+			using func_t = decltype(&Actor::HandleDefaultAnimationSwitch);
+			static REL::Relocation<func_t> func{ ID::Actor::HandleDefaultAnimationSwitch };
+			return func(this);
+		}
+
+		void HandleItemEquip(bool bCullBone)
+		{
+			using func_t = decltype(&Actor::HandleItemEquip);
+			static REL::Relocation<func_t> func{ ID::Actor::HandleItemEquip };
+			return func(this, bCullBone);
+		}
+
+		bool HasObjects(TESBoundObject* a_obj, PACKAGE_OBJECT_TYPE a_formID, std::int32_t a_number, std::uint32_t a_id, PACKAGE_OBJECT_TYPE& a_matchID)
+		{
+			using func_t = decltype(&Actor::HasObjects);
+			static REL::Relocation<func_t> func{ ID::Actor::HasObjects };
+			return func(this, a_obj, a_formID, a_number, a_id, a_matchID);
+		}
+
+		void InitiateDoNothingPackage()
+		{
+			using func_t = decltype(&Actor::InitiateDoNothingPackage);
+			static REL::Relocation<func_t> func{ ID::Actor::InitiateDoNothingPackage };
+			return func(this);
+		}
+
+		bool IsCrippled()
+		{
+			using func_t = decltype(&Actor::IsCrippled);
+			static REL::Relocation<func_t> func{ ID::Actor::IsCrippled };
+			return func(this);
+		}
+
+		bool IsFollowing()
+		{
+			using func_t = decltype(&Actor::IsFollowing);
+			static REL::Relocation<func_t> func{ ID::Actor::IsFollowing };
+			return func(this);
+		}
+
+		[[nodiscard]] bool IsJumping()
+		{
+			using func_t = decltype(&Actor::IsJumping);
+			static REL::Relocation<func_t> func{ ID::Actor::IsJumping };
+			return func(this);
+		}
+
+		bool IsPathValid()
+		{
+			using func_t = decltype(&Actor::IsPathValid);
+			static REL::Relocation<func_t> func{ ID::Actor::IsPathValid };
+			return func(this);
+		}
+
+		bool IsPathing()
+		{
+			using func_t = decltype(&Actor::IsPathing);
+			static REL::Relocation<func_t> func{ ID::Actor::IsPathing };
+			return func(this);
+		}
+
+		bool IsPathingComplete()
+		{
+			using func_t = decltype(&Actor::IsPathingComplete);
+			static REL::Relocation<func_t> func{ ID::Actor::IsPathingComplete };
+			return func(this);
+		}
+
+		bool IsQuadruped()
+		{
+			using func_t = decltype(&Actor::IsQuadruped);
+			static REL::Relocation<func_t> func{ ID::Actor::IsQuadruped };
+			return func(this);
+		}
+
+		bool IsSneaking()
+		{
+			using func_t = decltype(&Actor::IsSneaking);
+			static REL::Relocation<func_t> func{ ID::Actor::IsSneaking };
+			return func(this);
+		}
+
+		bool IsVisible() const
+		{
+			constexpr auto all = std::to_underlying(ACTOR_VISIBILITY_MASK::kAll);
+			return ((visFlags & all) & 0xF) == all;
+		}
+
+		bhkCharacterController* Move(float a_deltaTime, NiPoint3 a_deltaPos, bool a_defer)
+		{
+			using func_t = decltype(&Actor::Move);
+			static REL::Relocation<func_t> func{ ID::Actor::Move };
+			return func(this, a_deltaTime, a_deltaPos, a_defer);
+		}
+
+		bool PerformAction(BGSAction* a_action, TESObjectREFR* a_target)
+		{
+			using func_t = decltype(&Actor::PerformAction);
+			static REL::Relocation<func_t> func{ ID::Actor::PerformAction };
+			return func(this, a_action, a_target);
+		}
+
+		void RemovePerk(BGSPerk* a_perk)
+		{
+			using func_t = decltype(&Actor::RemovePerk);
+			static REL::Relocation<func_t> func{ ID::Actor::RemovePerk };
+			return func(this, a_perk);
+		}
+
+		void Reset3D(bool a_reloadAll, std::uint32_t a_additionalFlags, bool a_queueReset, std::uint32_t a_excludeFlags)
+		{
+			using func_t = decltype(&Actor::Reset3D);
+			static REL::Relocation<func_t> func{ ID::Actor::Reset3D };
+			return func(this, a_reloadAll, a_additionalFlags, a_queueReset, a_excludeFlags);
+		}
+
+		void RewardExperience(float a_amount, bool a_direct, TESObjectREFR* a_actionTarget, TESObjectREFR* a_killWeapon)
+		{
+			using func_t = decltype(&Actor::RewardExperience);
+			static REL::Relocation<func_t> func{ ID::Actor::RewardExperience };
+			return func(this, a_amount, a_direct, a_actionTarget, a_killWeapon);
+		}
+
+		void SetCurrentAmmo(BGSEquipIndex a_equipIndex, TESAmmo* a_ammo)
+		{
+			if (currentProcess) {
+				currentProcess->SetCurrentAmmo(a_equipIndex, a_ammo);
+			}
+		}
+
+		void SetCurrentAmmoCount(BGSEquipIndex a_equipIndex, std::uint32_t a_count)
+		{
+			using func_t = decltype(&Actor::SetCurrentAmmoCount);
+			static REL::Relocation<func_t> func{ ID::Actor::SetCurrentAmmoCount };
+			return func(this, a_equipIndex, a_count);
+		}
+
+		void SetGunState(GUN_STATE a_gunState, bool a_val = true)
+		{
+			using func_t = decltype(&Actor::SetGunState);
+			static REL::Relocation<func_t> func{ ID::Actor::SetGunState };
+			return func(this, a_gunState, a_val);
+		}
+
+		void SetHeading(float a_angle)
+		{
+			using func_t = decltype(&Actor::SetHeading);
+			static REL::Relocation<func_t> func{ ID::Actor::SetHeading };
+			return func(this, a_angle);
+		}
+
+		void TrespassAlarm(TESObjectREFR* a_refr, TESForm* a_owner, std::int32_t a_crime)
+		{
+			using func_t = decltype(&Actor::TrespassAlarm);
+			static REL::Relocation<func_t> func{ ID::Actor::TrespassAlarm };
+			return func(this, a_refr, a_owner, a_crime);
+		}
+
+		void UpdateVoiceTimer(bool a_force)
+		{
+			using func_t = decltype(&Actor::UpdateVoiceTimer);
+			static REL::Relocation<func_t> func{ ID::Actor::UpdateVoiceTimer };
+			return func(this, a_force);
+		}
+
+		BGSBodyPartData* GetBodyPartData()
+		{
+			using func_t = decltype(&Actor::GetBodyPartData);
+			static REL::Relocation<func_t> func{ ID::Actor::GetBodyPartData };
+			return func(this);
+		}
+
+		BGSObjectInstance* GetEquippedItem(BGSObjectInstance* a_result, BGSEquipIndex a_equipIndex)
+		{
+			using func_t = decltype(&Actor::GetEquippedItem);
+			static REL::Relocation<func_t> func{ ID::Actor::GetEquippedItem };
+			return func(this, a_result, a_equipIndex);
+		}
+
+		TESFaction* GetCrimeTrackingFaction()
+		{
+			using func_t = decltype(&Actor::GetCrimeTrackingFaction);
+			static REL::Relocation<func_t> func{ ID::Actor::GetCrimeTrackingFaction };
+			return func(this);
+		}
+
+		void ForceDetect(Actor* a_target, bool a_forceLOS, float a_time)
+		{
+			using func_t = decltype(&Actor::ForceDetect);
+			static REL::Relocation<func_t> func{ ID::Actor::ForceDetect };
+			return func(this, a_target, a_forceLOS, a_time);
+		}
+
+		void UnequipObject(TESBoundObject* a_object, ObjectEquipParams a_params)
+		{
+			using func_t = decltype(&Actor::UnequipObject);
+			static REL::Relocation<func_t> func{ ID::Actor::UnequipObject };
+			return func(this, a_object, a_params);
+		}
+
+		void UpdateSprinting()
+		{
+			using func_t = decltype(&Actor::UpdateSprinting);
+			static REL::Relocation<func_t> func{ ID::Actor::UpdateSprinting };
+			return func(this);
+		}
+
+		std::uint8_t GetMobilityCrippled()
+		{
+			using func_t = decltype(&Actor::GetMobilityCrippled);
+			static REL::Relocation<func_t> func{ ID::Actor::GetMobilityCrippled };
+			return func(this);
+		}
+
+		void SPECIALModifiedCallback(const ActorValueInfo* a_info, float a_originalValue, float a_delta)
+		{
+			using func_t = decltype(&Actor::SPECIALModifiedCallback);
+			static REL::Relocation<func_t> func{ ID::Actor::SPECIALModifiedCallback };
+			return func(this, a_info, a_originalValue, a_delta);
+		}
+
+		void StopInteractingQuick(bool a_instance, bool a_moveActor, bool a_update3D)
+		{
+			using func_t = decltype(&Actor::StopInteractingQuick);
+			static REL::Relocation<func_t> func{ ID::Actor::StopInteractingQuick };
+			return func(this, a_instance, a_moveActor, a_update3D);
+		}
+
+		void CalculateDetectionFormula(Actor* a_target, DetectionData* a_detectionData)
+		{
+			using func_t = decltype(&Actor::CalculateDetectionFormula);
+			static REL::Relocation<func_t> func{ ID::Actor::CalculateDetectionFormula };
+			return func(this, a_target, a_detectionData);
+		}
+
+		void DoHitMe(const HitData* a_data)
+		{
+			using func_t = decltype(&Actor::DoHitMe);
+			static REL::Relocation<func_t> func{ ID::Actor::DoHitMe };
+			return func(this, a_data);
+		}
+
+		// members
+		NiTFlags<std::uint32_t, Actor>                    niFlags;                      // 2D0
+		float                                             updateTargetTimer;            // 2D4
+		NiPoint3                                          editorLocCoord;               // 2D8
+		NiPoint3                                          editorLocRot;                 // 2E4
+		TESForm*                                          editorLocForm;                // 2F0
+		BGSLocation*                                      editorLocation;               // 2F8
+		AIProcess*                                        currentProcess;               // 300
+		ActorMover*                                       actorMover;                   // 308
+		BGSKeyword*                                       speakingAnimArchType;         // 310
+		BSTSmartPointer<MovementControllerNPC>            movementController;           // 318
+		TESPackage*                                       initialPackage;               // 320
+		CombatController*                                 combatController;             // 328
+		TESFaction*                                       vendorFaction;                // 330
+		ActorValueStorage                                 avStorage;                    // 338
+		BGSDialogueBranch*                                exclusiveBranch;              // 370
+		REX::TEnumSet<ACTOR_CRITICAL_STAGE, std::int32_t> criticalStage;                // 378
+		ObjectRefHandle                                   dialogueItemTarget;           // 37C
+		ActorHandle                                       currentCombatTarget;          // 380
+		ActorHandle                                       myKiller;                     // 384
+		float                                             checkMyDeadBodyTimer;         // 388
+		float                                             voiceTimer;                   // 38C
+		float                                             voiceLengthTotal;             // 390
+		float                                             underWaterTimer;              // 394
+		std::int32_t                                      thiefCrimeStamp;              // 398
+		std::int32_t                                      actionValue;                  // 39C
+		float                                             timeronAction;                // 3A0
+		AITimeStamp                                       calculateVendorFactionTimer;  // 3A4
+		std::uint32_t                                     intimidateBribeDayStamp;      // 3A8
+		float                                             equippedWeight;               // 3AC
+		BSTSmallArray<SpellItem*>                         addedSpells;                  // 3B0
+		ActorMagicCaster*                                 magicCasters[4];              // 3C8
+		MagicItem*                                        selectedSpell[4];             // 3E8
+		CastPowerItem*                                    castPowerItems;               // 408
+		TESForm*                                          selectedPower;                // 410
+		TESRace*                                          race;                         // 418
+		Perks*                                            perks;                        // 420
+		BSTSmartPointer<BipedAnim>                        biped;                        // 428
+		BSNonReentrantSpinLock                            addingToOrRemovingFromScene;  // 430
+		BSReadWriteLock                                   perkArrayLock;                // 434
+		REX::TEnumSet<BOOL_FLAGS, std::uint32_t>          boolFlags;                    // 43C
+		std::uint32_t                                     moreFlags;                    // 440
+		Modifiers                                         healthModifiers;              // 444
+		Modifiers                                         actionPointsModifiers;        // 450
+		Modifiers                                         staminaModifiers;             // 45C
+		Modifiers                                         radsModifiers;                // 468
+		float                                             lastUpdate;                   // 474
+		std::uint32_t                                     lastSeenTime;                 // 478
+		float                                             armorRating;                  // 47C
+		float                                             armorBaseFactorSum;           // 480
+		std::uint32_t                                     visFlags: 4;                  // 484:00
+		std::int8_t                                       raceSwitchPending: 1;         // 488:0
+		std::int8_t                                       soundCallBackSet;             // 489
+		bool                                              trespassing;                  // 48A
+	};
+	static_assert(sizeof(Actor) == 0x490);
+}

plugin/lib/commonlibf4/include/RE/A/ActorEquipManager.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTSingleton.h"
+
+namespace RE
+{
+	class BGSEquipSlot;
+	class BGSObjectInstance;
+	class EquippedItem;
+
+	namespace ActorEquipManagerEvent
+	{
+		class Event;
+	}
+
+	class ActorEquipManager :
+		public BSTSingletonSDM<ActorEquipManager>,            // 00
+		public BSTEventSource<ActorEquipManagerEvent::Event>  // 08
+	{
+	public:
+		enum class CanEquipResult
+		{
+			kSuccess = 0x0,
+			kInvalidItem = 0x1,
+			kNoModEquip = 0x2,
+			kPAWhileNotInPA = 0x3,
+			kNonPAWhileInPA = 0x4,
+			kEquipStateLocked = 0x5,
+			kItemBroken = 0x6,
+			kNoEquipKeyword = 0x7
+		};
+
+		[[nodiscard]] static ActorEquipManager* GetSingleton()
+		{
+			static REL::Relocation<ActorEquipManager**> singleton{ ID::ActorEquipManager::Singleton };
+			return *singleton;
+		}
+
+		bool EquipObject(
+			Actor*                   a_actor,
+			const BGSObjectInstance& a_object,
+			std::uint32_t            a_stackID,
+			std::uint32_t            a_number,
+			const BGSEquipSlot*      a_slot,
+			bool                     a_queueEquip,
+			bool                     a_forceEquip,
+			bool                     a_playSounds,
+			bool                     a_applyNow,
+			bool                     a_locked)
+		{
+			using func_t = decltype(&ActorEquipManager::EquipObject);
+			static REL::Relocation<func_t> func{ ID::ActorEquipManager::EquipObject };
+			return func(this, a_actor, a_object, a_stackID, a_number, a_slot, a_queueEquip, a_forceEquip, a_playSounds, a_applyNow, a_locked);
+		}
+
+		bool UnequipObject(
+			Actor*                   a_actor,
+			const BGSObjectInstance* a_object,
+			std::uint32_t            a_number,
+			const BGSEquipSlot*      a_slot,
+			std::uint32_t            a_stackID,
+			bool                     a_queueEquip,
+			bool                     a_forceEquip,
+			bool                     a_playSounds,
+			bool                     a_applyNow,
+			const BGSEquipSlot*      a_slotBeingReplaced)
+		{
+			using func_t = decltype(&ActorEquipManager::UnequipObject);
+			static REL::Relocation<func_t> func{ ID::ActorEquipManager::UnequipObject };
+			return func(this, a_actor, a_object, a_number, a_slot, a_stackID, a_queueEquip, a_forceEquip, a_playSounds, a_applyNow, a_slotBeingReplaced);
+		}
+
+		void UnequipItem(Actor* a_actor, const EquippedItem* a_equippedItem, bool a_queueEquip)
+		{
+			using func_t = decltype(&ActorEquipManager::UnequipItem);
+			static REL::Relocation<func_t> func{ ID::ActorEquipManager::UnequipItem };
+			return func(this, a_actor, a_equippedItem, a_queueEquip);
+		}
+	};
+	static_assert(sizeof(ActorEquipManager) == 0x60);
+}

plugin/lib/commonlibf4/include/RE/A/ActorEquipManagerEvent.h

@@ -0,0 +1,26 @@
+#pragma once
+
+namespace RE
+{
+	class BGSObjectInstance;
+
+	namespace ActorEquipManagerEvent
+	{
+		enum class Type : std::int32_t
+		{
+			kEquip = 0x0,
+			kUnequip = 0x1
+		};
+
+		class Event
+		{
+		public:
+			// members
+			REX::TEnumSet<Type, std::uint16_t> changeType;     // 00
+			const BGSObjectInstance*           itemAffected;   // 08
+			Actor*                             actorAffected;  // 10
+			std::uint32_t                      stackID;        // 18
+		};
+		static_assert(sizeof(Event) == 0x20);
+	}
+}

plugin/lib/commonlibf4/include/RE/A/ActorItemEquipped.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RE
+{
+	namespace ActorItemEquipped
+	{
+		class Event
+		{
+		public:
+			// members
+			const TESBoundObject* item;      // 00
+			const Actor*          equipper;  // 08
+		};
+		static_assert(sizeof(Event) == 0x10);
+	}
+}

plugin/lib/commonlibf4/include/RE/A/ActorKill.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RE
+{
+	namespace ActorKill
+	{
+		class Event
+		{
+		public:
+			// members
+			const Actor* killer;
+			const Actor* victim;
+		};
+		static_assert(sizeof(Event) == 0x10);
+	}
+}

plugin/lib/commonlibf4/include/RE/A/ActorMotionFeedbackData.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class ActorMotionFeedbackData
+	{
+	public:
+		// members
+		NiPoint3 desiredWorldDelta;  // 00
+		NiPoint3 actualWorldDelta;   // 0C
+		float    previousSpeed;      // 18
+		float    previousDirection;  // 1C
+		float    currentHeading;     // 20
+	};
+	static_assert(sizeof(ActorMotionFeedbackData) == 0x24);
+}

plugin/lib/commonlibf4/include/RE/A/ActorMovementData.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/M/MovementData.h"
+#include "RE/M/MovementTweenerOutputData.h"
+
+namespace RE
+{
+	class ActorMovementData
+	{
+	public:
+		// members
+		MovementData              handlerData;  // 00
+		MovementTweenerOutputData tweenerData;  // 30
+	};
+	static_assert(sizeof(ActorMovementData) == 0x50);
+}

plugin/lib/commonlibf4/include/RE/A/ActorPackage.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSpinLock.h"
+
+namespace RE
+{
+	class ActorPackageData;
+
+	class ActorPackage
+	{
+	public:
+		// members
+		BSSpinLock        packageLock;            // 00
+		TESPackage*       package;                // 08
+		ActorPackageData* data;                   // 10
+		ObjectRefHandle   target;                 // 18
+		std::int32_t      currentProcedureIndex;  // 1C
+		float             packageStartTime;       // 20
+		std::uint32_t     modifiedPackageFlag;    // 24
+		std::uint16_t     modifiedInterruptFlag;  // 28
+		std::int8_t       actorPackageFlags;      // 2A
+		std::int8_t       preferredSpeed;         // 2B
+	};
+	static_assert(sizeof(ActorPackage) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/A/ActorPackageData.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/P/PTYPE.h"
+
+namespace RE
+{
+	class ActorPackageLoadFormBuffer;
+	class BGSSaveFormBuffer;
+	class IProcedureTreeExecState;
+
+	class __declspec(novtable) ActorPackageData
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActorPackageData };
+		static constexpr auto VTABLE{ VTABLE::ActorPackageData };
+
+		virtual ~ActorPackageData();  // 00
+
+		// add
+		virtual PTYPE                    GetPackageType() = 0;                                                                              // 01
+		virtual IProcedureTreeExecState* GetProcedureExecState() { return nullptr; }                                                        // 02
+		virtual void                     SetProcedureExecState([[maybe_unused]] IProcedureTreeExecState& a_procedureExecState) { return; }  // 03
+		virtual void                     ClearProcedureExecState() { return; }                                                              // 04
+		virtual void                     SaveGame(BGSSaveFormBuffer* a_saveGameBuffer) = 0;                                                 // 05
+		virtual void                     LoadGame(ActorPackageLoadFormBuffer* a_loadGameBuffer) = 0;                                        // 06
+		virtual void                     InitLoadGame([[maybe_unused]] ActorPackageLoadFormBuffer* a_loadGameBuffer) { return; }            // 07
+		virtual void                     ResetPackData([[maybe_unused]] TESPackage* a_pack) { return; }                                     // 08
+	};
+	static_assert(sizeof(ActorPackageData) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/A/ActorStance.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	class ActorStance
+	{
+	public:
+		// members
+		std::uint8_t stance;          // 00
+		std::uint8_t stanceModifier;  // 01
+		bool         mirrored;        // 02
+	};
+	static_assert(sizeof(ActorStance) == 0x03);
+}

plugin/lib/commonlibf4/include/RE/A/ActorState.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "RE/I/IMovementState.h"
+#include "RE/W/WEAPON_STATE.h"
+
+namespace RE
+{
+	enum class GUN_STATE;
+	enum class INTERACTING_STATE;
+	enum class SIT_SLEEP_STATE;
+
+	class __declspec(novtable) ActorState :
+		public IMovementState  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActorState };
+		static constexpr auto VTABLE{ VTABLE::ActorState };
+
+		// add
+		virtual bool            SetWeaponMagicDrawn(bool a_drawn);                // 21
+		virtual bool            SetWeaponState(WEAPON_STATE a_state);             // 22
+		virtual bool            DoSetSitSleepState(SIT_SLEEP_STATE a_state) = 0;  // 23
+		virtual SIT_SLEEP_STATE DoGetSitSleepState() const = 0;                   // 24
+		virtual bool            SetInIronSightsImpl(bool a_sighted) = 0;          // 25
+		virtual void            SetReloadingImpl(bool a_reloading);               // 26
+
+		[[nodiscard]] bool GetWeaponMagicDrawn() const noexcept { return weaponState >= WEAPON_STATE::kDrawn; }
+		[[nodiscard]] bool IsSwimming() const noexcept { return DoGetMoveModeBits(0x400); }
+
+		// members
+		std::uint32_t     moveMode: 14;            // 08:00
+		std::uint32_t     flyState: 3;             // 08:14
+		std::uint32_t     lifeState: 4;            // 08:17
+		std::uint32_t     knockState: 4;           // 08:21
+		std::uint32_t     meleeAttackState: 3;     // 08:25
+		std::uint32_t     talkingToPlayer: 1;      // 08:28
+		std::uint32_t     forceRun: 1;             // 08:29
+		std::uint32_t     forceSneak: 1;           // 08:30
+		std::uint32_t     headTracking: 1;         // 08:31
+		std::uint32_t     reanimating: 1;          // 0C:00
+		WEAPON_STATE      weaponState: 3;          // 0C:01
+		std::uint32_t     wantBlocking: 1;         // 0C:04
+		std::uint32_t     flightBlocked: 1;        // 0C:05
+		std::uint32_t     recoil: 2;               // 0C:06
+		std::uint32_t     allowFlying: 1;          // 0C:08
+		std::uint32_t     staggered: 1;            // 0C:09
+		std::uint32_t     inWrongProcessLevel: 1;  // 0C:10
+		std::uint32_t     stance: 3;               // 0C:11
+		GUN_STATE         gunState: 4;             // 0C:14
+		INTERACTING_STATE interactingState: 2;     // 0C:18
+		std::uint32_t     headTrackRotation: 1;    // 0C:20
+		std::uint32_t     inSyncAnim: 1;           // 0C:21
+
+	private:
+		bool DoGetMoveModeBits(std::uint16_t a_bits) const { return (a_bits & moveMode & 0x3FFF) == a_bits; }
+	};
+	static_assert(sizeof(ActorState) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/A/ActorUtils.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	class BGSInventoryItem;
+
+	namespace ActorUtils
+	{
+		class __declspec(novtable) ArmorRatingVisitorBase
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::ActorUtils__ArmorRatingVisitorBase };
+			static constexpr auto VTABLE{ VTABLE::ActorUtils__ArmorRatingVisitorBase };
+
+			ArmorRatingVisitorBase()
+			{
+				REX::EMPLACE_VTABLE(this);
+			}
+
+			ArmorRatingVisitorBase(const Actor* a_actor, bool a_checkEquipped)
+			{
+				ctor(a_actor, a_checkEquipped);
+			}
+
+			// add
+			virtual bool ShouldProcess(TESBoundObject*) { return 1; };  // 00
+			virtual void PostProcess(TESBoundObject*) {};               // 01
+
+			std::int64_t operator()(const BGSInventoryItem* a_item, std::uint32_t a_stackID)
+			{
+				using func_t = decltype(&ArmorRatingVisitorBase::operator());
+				static REL::Relocation<func_t> func{ ID::ActorUtils::ArmorRatingVisitorBase::_operator };
+				return func(this, a_item, a_stackID);
+			}
+
+			// members
+			Actor* actor;          // 08
+			float  rating;         // 10
+			float  armorPerks;     // 14
+			bool   checkEquipped;  // 18
+
+		private:
+			void ctor(const Actor* a_actor, bool a_checkEquipped)
+			{
+				using func_t = decltype(&ArmorRatingVisitorBase::ctor);
+				static REL::Relocation<func_t> func{ ID::ActorUtils::ArmorRatingVisitorBase::ctor };
+				return func(this, a_actor, a_checkEquipped);
+			}
+		};
+		static_assert(sizeof(ArmorRatingVisitorBase) == 0x20);
+
+		class __declspec(novtable) ArmorRatingVisitor :
+			public ArmorRatingVisitorBase  // 00
+		{
+			static constexpr auto RTTI{ RTTI::ActorUtils__ArmorRatingVisitor };
+			static constexpr auto VTABLE{ VTABLE::ActorUtils__ArmorRatingVisitor };
+
+			BSScrapArray<TESBoundObject*> foundArmor;  // 20
+		};
+		static_assert(sizeof(ArmorRatingVisitor) == 0x40);
+
+		static inline float GetEquippedArmorDamageResistance(Actor* a_actor, const ActorValueInfo* a_info)
+		{
+			using func_t = decltype(ActorUtils::GetEquippedArmorDamageResistance);
+			static REL::Relocation<func_t> func{ ID::ActorUtils::GetEquippedArmorDamageResistance };
+			return func(a_actor, a_info);
+		}
+	}
+}

plugin/lib/commonlibf4/include/RE/A/ActorValue.h

@@ -0,0 +1,197 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTSingleton.h"
+
+namespace RE
+{
+	class ActorValue :
+		public BSTSingletonImplicit<ActorValue>  // 000
+	{
+	public:
+		enum class AVType
+		{
+			kDerivedAttribute = 0x0,
+			kAttribute = 0x1,
+			kSkill = 0x2,
+			kAIAttribute = 0x3,
+			kResistance = 0x4,
+			kCondition = 0x5,
+			kCharge = 0x6,
+			kIntValue = 0x7,
+			kVariable = 0x8,
+			kResource = 0x9
+		};
+
+		enum class Flags : std::int32_t
+		{
+			kDepreciated = 1 << 1,
+			kEnumeration = 1 << 2,
+			kNoScriptModAV = 1 << 3,
+			kCache = 1 << 4,
+			kCachePermenant = 1 << 5,
+			kAlwaysClamp = 1 << 6,
+			kImplicitBase0 = 1 << 10,
+			kImplicitBase1 = 1 << 11,
+			kImplicitBase100 = 1 << 12,
+			kUserDefined = 1 << 13,
+			kDerived = 1 << 15,
+			kBaseUseAutoCalc = 1 << 16,
+			kMin1 = 1 << 20,
+			kMax10 = 1 << 21,
+			kMax100 = 1 << 22,
+			kScaleBy100 = 1 << 23,
+			kPercentage = 1 << 24,
+			kDamageMinZero = 1 << 25,
+			kDamageIsPositive = 1 << 26,
+			kGodModeNoDamage = 1 << 27,
+			kDoesNotRecover = 1 << 28,
+			kHardcoded = 1 << 31,
+		};
+
+		[[nodiscard]] static ActorValue* GetSingleton()
+		{
+			using func_t = decltype(&ActorValue::GetSingleton);
+			static REL::Relocation<func_t> func{ ID::ActorValue::Singleton };
+			return func();
+		}
+
+		// members
+		ActorValueInfo*           absorbChance;                       // 000
+		ActorValueInfo*           actionPoints;                       // 008
+		ActorValueInfo*           aggression;                         // 010
+		ActorValueInfo*           agility;                            // 018
+		ActorValueInfo*           aimStability;                       // 020
+		ActorValueInfo*           alchemy;                            // 028
+		ActorValueInfo*           animationMult;                      // 030
+		ActorValueInfo*           armorPerks;                         // 038
+		ActorValueInfo*           assistance;                         // 040
+		ActorValueInfo*           attackDamageMult;                   // 048
+		ActorValueInfo*           blindness;                          // 050
+		ActorValueInfo*           block;                              // 058
+		ActorValueInfo*           bloodyMess;                         // 060
+		ActorValueInfo*           bowSpeedBonus;                      // 068
+		ActorValueInfo*           bowStaggerBonus;                    // 070
+		ActorValueInfo*           brainCondition;                     // 078
+		ActorValueInfo*           carryWeight;                        // 080
+		ActorValueInfo*           charisma;                           // 088
+		ActorValueInfo*           combatHealthRegenMult;              // 090
+		ActorValueInfo*           confidence;                         // 098
+		ActorValueInfo*           criticalChance;                     // 0A0
+		ActorValueInfo*           damageResistance;                   // 0A8
+		ActorValueInfo*           deafness;                           // 0B0
+		ActorValueInfo*           enchanting;                         // 0B8
+		ActorValueInfo*           endurance;                          // 0C0
+		ActorValueInfo*           enduranceCondition;                 // 0C8
+		ActorValueInfo*           experience;                         // 0D0
+		ActorValueInfo*           health;                             // 0D8
+		ActorValueInfo*           healRateMult;                       // 0E0
+		ActorValueInfo*           idleChatterTimeMin;                 // 0E8
+		ActorValueInfo*           idleChatterTimeMAx;                 // 0F0
+		ActorValueInfo*           ignoreCrippledLimbs;                // 0F8
+		ActorValueInfo*           intelligence;                       // 100
+		ActorValueInfo*           invisibility;                       // 108
+		ActorValueInfo*           karma;                              // 110
+		ActorValueInfo*           leftAttackCondition;                // 118
+		ActorValueInfo*           leftItemCharge;                     // 120
+		ActorValueInfo*           leftMobiltyCondition;               // 128
+		ActorValueInfo*           leftWeaponSpeedMult;                // 130
+		ActorValueInfo*           lockpicking;                        // 138
+		ActorValueInfo*           luck;                               // 140
+		ActorValueInfo*           mass;                               // 148
+		ActorValueInfo*           meleeDamage;                        // 150
+		ActorValueInfo*           morality;                           // 158
+		ActorValueInfo*           movementNoiseMult;                  // 160
+		ActorValueInfo*           nightEyeBonus;                      // 168
+		ActorValueInfo*           perception;                         // 170
+		ActorValueInfo*           perceptionCondition;                // 178
+		ActorValueInfo*           pickpocket;                         // 180
+		ActorValueInfo*           poisonResistance;                   // 188
+		ActorValueInfo*           powerArmorBattery;                  // 190
+		ActorValueInfo*           powerArmorHeadCondition;            // 198
+		ActorValueInfo*           powerArmorTorsoCondition;           // 1A0
+		ActorValueInfo*           powerArmorLeftArmCondition;         // 1A8
+		ActorValueInfo*           powerArmorRightArmCondition;        // 1B0
+		ActorValueInfo*           powerArmorLeftLegCondition;         // 1B8
+		ActorValueInfo*           powerArmorRightLegCondition;        // 1C0
+		ActorValueInfo*           radHealthMax;                       // 1C8
+		ActorValueInfo*           rads;                               // 1D0
+		ActorValueInfo*           fatigueAPMax;                       // 1D8
+		ActorValueInfo*           fatigue;                            // 1E0
+		ActorValueInfo*           reflectDamage;                      // 1E8
+		ActorValueInfo*           restoreConditionRate;               // 1F0
+		ActorValueInfo*           rightAttackCondition;               // 1F8
+		ActorValueInfo*           rightItemCharge;                    // 200
+		ActorValueInfo*           rightMobilityCondition;             // 208
+		ActorValueInfo*           rotationSpeedCondition;             // 210
+		ActorValueInfo*           shieldPerks;                        // 218
+		ActorValueInfo*           shoutRecoveryMult;                  // 220
+		ActorValueInfo*           sneak;                              // 228
+		ActorValueInfo*           speechcraft;                        // 230
+		ActorValueInfo*           speedMult;                          // 238
+		ActorValueInfo*           stamina;                            // 240
+		ActorValueInfo*           strength;                           // 248
+		ActorValueInfo*           suspicious;                         // 250
+		ActorValueInfo*           telekinesis;                        // 258
+		ActorValueInfo*           unarmedDamage;                      // 260
+		ActorValueInfo*           vansPerk;                           // 268
+		ActorValueInfo*           wardPower;                          // 270
+		ActorValueInfo*           waitingForPlayer;                   // 278
+		ActorValueInfo*           waterBreathing;                     // 280
+		ActorValueInfo*           waterWalking;                       // 288
+		ActorValueInfo*           weaponSpeedMult;                    // 290
+		ActorValueInfo*           weapReloadSpeedMult;                // 298
+		ActorValueInfo*           restoreHealthRate;                  // 2A0
+		ActorValueInfo*           restoreAPRate;                      // 2A8
+		ActorValueInfo*           apRateMult;                         // 2B0
+		ActorValueInfo*           restoreRadsRate;                    // 2B8
+		ActorValueInfo*           radsRateMult;                       // 2C0
+		ActorValueInfo*           restoreFatigueRate;                 // 2C8
+		ActorValueInfo*           fatigueRateMult;                    // 2D0
+		ActorValueInfo*           conditionRateMult;                  // 2D8
+		ActorValueInfo*           fireResistance;                     // 2E0
+		ActorValueInfo*           electricalResistance;               // 2E8
+		ActorValueInfo*           frostResistance;                    // 2F0
+		ActorValueInfo*           magicResistance;                    // 2F8
+		ActorValueInfo*           radIngestionResistance;             // 300
+		ActorValueInfo*           radExposureResistance;              // 308
+		ActorValueInfo*           energy;                             // 310
+		ActorValueInfo*           energyResistance;                   // 318
+		ActorValueInfo*           paralysis;                          // 320
+		ActorValueInfo*           attackConditionAlt1;                // 328
+		ActorValueInfo*           attackConditionAlt2;                // 330
+		ActorValueInfo*           attackConditionAlt3;                // 338
+		ActorValueInfo*           powerGenerated;                     // 340
+		ActorValueInfo*           powerRadation;                      // 348
+		ActorValueInfo*           powerRequired;                      // 350
+		ActorValueInfo*           resourceFood;                       // 358
+		ActorValueInfo*           resourceWater;                      // 360
+		ActorValueInfo*           resourceSafety;                     // 368
+		ActorValueInfo*           resourceBed;                        // 370
+		ActorValueInfo*           resourceHappiness;                  // 378
+		ActorValueInfo*           resourceArtillery;                  // 380
+		ActorValueInfo*           workshopItemOverlap;                // 388
+		ActorValueInfo*           workshopItemClampDirection;         // 390
+		ActorValueInfo*           workshopItemZOffset;                // 398
+		ActorValueInfo*           workshopPlayerOwned;                // 3A0
+		ActorValueInfo*           workshopActorWounded;               // 3A8
+		ActorValueInfo*           workshopStackableItem;              // 3B0
+		ActorValueInfo*           workshopSnapPointRadius;            // 3B8
+		ActorValueInfo*           workshopAnythingIsGround;           // 3C0
+		ActorValueInfo*           workshopMaxTriangles;               // 3C8
+		ActorValueInfo*           workshopMaxDraws;                   // 3D0
+		ActorValueInfo*           workshopCurrentTriangles;           // 3D8
+		ActorValueInfo*           workshopCurrentDraws;               // 3E0
+		ActorValueInfo*           workshopIgnoreSimpleIntersections;  // 3E8
+		ActorValueInfo*           workshopAllowUnsupportedStacking;   // 3F0
+		ActorValueInfo*           workshopSnapTransmitsPower;         // 3F8
+		ActorValueInfo*           workshopPowerConnection;            // 400
+		ActorValueInfo*           logicOperation;                     // 408
+		ActorValueInfo*           logicOutput;                        // 410
+		ActorValueInfo*           ignorePlayerWhileFrenzied;          // 418
+		BSTArray<ActorValueInfo*> hardcodedActorValues;               // 420
+		BSTArray<ActorValueInfo*> conditionActorValues;               // 438
+		std::uint32_t             avTypeCounts[10];                   // 450
+	};
+	static_assert(sizeof(ActorValue) == 0x478);
+}

plugin/lib/commonlibf4/include/RE/A/ActorValueEvents.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RE
+{
+	namespace ActorValueEvents
+	{
+		class ActorValueChangedEvent
+		{
+		public:
+			// members
+			const ActorValueInfo& actorValue;  // 00
+			TESObjectREFR*        owner;       // 08
+		};
+		static_assert(sizeof(ActorValueChangedEvent) == 0x10);
+	}
+}

plugin/lib/commonlibf4/include/RE/A/ActorValueInfo.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "RE/A/ActorValue.h"
+#include "RE/B/BGSLocalizedString.h"
+#include "RE/B/BSStringT.h"
+#include "RE/T/TESDescription.h"
+#include "RE/T/TESForm.h"
+#include "RE/T/TESFullName.h"
+
+namespace RE
+{
+	class ActorValueOwner;
+
+	class __declspec(novtable) ActorValueInfo :
+		public TESForm,        // 000
+		public TESFullName,    // 020
+		public TESDescription  // 030
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActorValueInfo };
+		static constexpr auto VTABLE{ VTABLE::ActorValueInfo };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kAVIF };
+
+		using ModifiedCallback_t = void(Actor* a_actor, const ActorValueInfo& a_info, float a_originalValue, float a_delta, Actor* a_actorSource);
+		using DerivationFunction_t = float(const ActorValueOwner* a_actor, const ActorValueInfo& a_info);
+
+		// members
+		std::function<ModifiedCallback_t>               modifiedCallback;          // 048
+		BSString                                        formEditorID;              // 088
+		ActorValueInfo*                                 dependentActorValues[15];  // 098
+		std::function<DerivationFunction_t>             derivationFunction;        // 110
+		const char*                                     enumNames[10];             // 150
+		BGSLocalizedString                              abbreviation;              // 1A0
+		std::int32_t                                    oldActorValue;             // 1A8
+		REX::TEnumSet<ActorValue::Flags, std::int32_t>  flags;                     // 1AC
+		REX::TEnumSet<ActorValue::AVType, std::int32_t> avType;                    // 1B0
+		std::uint32_t                                   numDependentActorValues;   // 1B4
+		std::uint32_t                                   enumCount;                 // 1B8
+		std::int32_t                                    fullCacheIndex;            // 1BC
+		std::int32_t                                    permanentCacheIndex;       // 1C0
+		float                                           defaultValue;              // 1C4
+		std::uint32_t                                   sortIndex;                 // 1C8
+	};
+	static_assert(sizeof(ActorValueInfo) == 0x1D0);
+}

plugin/lib/commonlibf4/include/RE/A/ActorValueOwner.h

@@ -0,0 +1,28 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_VALUE_MODIFIER;
+
+	class __declspec(novtable) ActorValueOwner
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActorValueOwner };
+		static constexpr auto VTABLE{ VTABLE::ActorValueOwner };
+
+		virtual ~ActorValueOwner() = default;  // 00
+
+		// add
+		virtual float GetActorValue([[maybe_unused]] const ActorValueInfo& a_info) const { return 0.0F; }                                                                         // 01
+		virtual float GetPermanentActorValue([[maybe_unused]] const ActorValueInfo& a_info) const { return 0.0F; }                                                                // 02
+		virtual float GetBaseActorValue([[maybe_unused]] const ActorValueInfo& a_info) const { return 0.0F; }                                                                     // 03
+		virtual void  SetBaseActorValue([[maybe_unused]] const ActorValueInfo& a_info, [[maybe_unused]] float a_value) { return; }                                                // 04
+		virtual void  ModBaseActorValue([[maybe_unused]] const ActorValueInfo& a_info, [[maybe_unused]] float a_delta) { return; }                                                // 05
+		virtual void  ModActorValue([[maybe_unused]] ACTOR_VALUE_MODIFIER a_modifier, [[maybe_unused]] const ActorValueInfo& a_info, [[maybe_unused]] float a_delta) { return; }  // 06
+		virtual float GetModifier([[maybe_unused]] ACTOR_VALUE_MODIFIER a_modifier, [[maybe_unused]] const ActorValueInfo& a_info) const { return 0.0F; }                         // 07
+		virtual void  RestoreActorValue([[maybe_unused]] const ActorValueInfo& a_info, [[maybe_unused]] float a_amount) { return; }                                               // 08
+		virtual void  SetActorValue(const ActorValueInfo& a_info, float a_value) { SetBaseActorValue(a_info, a_value); }                                                          // 09
+		virtual bool  GetIsPlayerOwner() const { return false; }                                                                                                                  // 0A
+	};
+	static_assert(sizeof(ActorValueOwner) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/A/ActorValueStorage.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTTuple.h"
+#include "RE/M/Modifiers.h"
+
+namespace RE
+{
+	class ActorValueStorage
+	{
+	public:
+		// members
+		BSTArray<BSTTuple<std::uint32_t, float>>     baseValues;  // 00
+		BSTArray<BSTTuple<std::uint32_t, Modifiers>> modifiers;   // 18
+		BSReadWriteLock                              avLock;      // 30
+	};
+	static_assert(sizeof(ActorValueStorage) == 0x38);
+}

plugin/lib/commonlibf4/include/RE/A/AimModel.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/B/BGSAimModel.h"
+#include "RE/B/BSSpring_SpringState.h"
+#include "RE/N/NiPoint2.h"
+
+namespace RE
+{
+	class __declspec(novtable) AimModel
+	{
+	public:
+		BGSAimModel::Data               aimModelData;          // 00
+		BSSpring::SpringState<NiPoint2> recoilSpring;          // 40
+		BSSpring::SpringState<NiPoint2> recoilDiminishSpring;  // 54
+		NiPoint2                        targetRecoilHead;      // 68
+		NiPoint2                        currentRecoilHead;     // 70
+		NiPoint2                        prevRecoilRad;         // 78
+		NiPoint2                        preShotAimRad;         // 80
+		Actor*                          actor;                 // 88
+		float                           fireConeSize;          // 90
+		float                           lastShotDeltaMs;       // 94
+		unsigned int                    continuousShots;       // 98
+	};
+	static_assert(sizeof(AimModel) == 0xA0);
+}

plugin/lib/commonlibf4/include/RE/A/AlarmPackage.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/B/BSSimpleList.h"
+#include "RE/T/TESPackage.h"
+
+namespace RE
+{
+	class Crime;
+
+	class __declspec(novtable) AlarmPackage :
+		public TESPackage  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::AlarmPackage };
+		static constexpr auto VTABLE{ VTABLE::AlarmPackage };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kPACK };
+
+		// members
+		BSSimpleList<Crime*> crimes;      // C8
+		bool                 forceGreet;  // D8
+	};
+	static_assert(sizeof(AlarmPackage) == 0xE0);
+}

plugin/lib/commonlibf4/include/RE/A/AlchemyItem.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "RE/B/BGSCraftingUseSound.h"
+#include "RE/B/BGSDestructibleObjectForm.h"
+#include "RE/B/BGSEquipType.h"
+#include "RE/B/BGSLocalizedString.h"
+#include "RE/B/BGSMessageIcon.h"
+#include "RE/B/BGSModelMaterialSwap.h"
+#include "RE/B/BGSPickupPutdownSounds.h"
+#include "RE/M/MagicItem.h"
+#include "RE/T/TESDescription.h"
+#include "RE/T/TESIcon.h"
+#include "RE/T/TESWeightForm.h"
+
+namespace RE
+{
+	class __declspec(novtable) AlchemyItem :
+		public MagicItem,                  // 000
+		public BGSModelMaterialSwap,       // 0D0
+		public TESIcon,                    // 110
+		public BGSMessageIcon,             // 120
+		public TESWeightForm,              // 138
+		public BGSEquipType,               // 148
+		public BGSDestructibleObjectForm,  // 158
+		public BGSPickupPutdownSounds,     // 168
+		public BGSCraftingUseSound,        // 180
+		public TESDescription              // 190
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::AlchemyItem };
+		static constexpr auto VTABLE{ VTABLE::AlchemyItem };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kALCH };
+
+		class Data :
+			public MagicItem::Data  // 00
+		{
+		public:
+			// members
+			SpellItem*              addictionItem;     // 08
+			float                   addictionChance;   // 10
+			BGSSoundDescriptorForm* consumptionSound;  // 18
+			BGSLocalizedString      addictionName;     // 20
+		};
+		static_assert(sizeof(Data) == 0x28);
+
+		// members
+		Data    data;         // 1A8
+		TESIcon messageIcon;  // 1D0
+	};
+	static_assert(sizeof(AlchemyItem) == 0x1E0);
+}

plugin/lib/commonlibf4/include/RE/A/AnimationSpeedInformationTypes.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	namespace AnimationSpeedInformationTypes
+	{
+		class AnimationStateAdjustment
+		{
+		public:
+			union Variable
+			{
+				float variableFloatValue;
+				int   variableIntValue;
+			};
+
+			// members
+			BSFixedString adjustmentName;      // 00
+			Variable      adjustmentVariable;  // 08
+			bool          useFloat;            // 0C
+			bool          isVariable;          // 0D
+		};
+		static_assert(sizeof(AnimationStateAdjustment) == 0x10);
+	}
+}

plugin/lib/commonlibf4/include/RE/A/AnimationStanceNodeLocationData.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	template <class T>
+	class AnimationStanceNodeLocationData
+	{
+	public:
+		// members
+		T nodeLocationArray[3];  // 00
+	};
+	static_assert(sizeof(AnimationStanceNodeLocationData<void*>) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/A/AnimationSystemUtils.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	namespace AnimationSystemUtils
+	{
+		inline bool WillEventChangeState(const TESObjectREFR& a_ref, const BSFixedString& a_evn)
+		{
+			using func_t = decltype(&WillEventChangeState);
+			static REL::Relocation<func_t> func{ ID::AnimationSystemUtils::WillEventChangeState };
+			return func(a_ref, a_evn);
+		}
+	}
+}

plugin/lib/commonlibf4/include/RE/A/ApplyChangesFunctor.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "RE/B/BGSInventoryItem.h"
+
+namespace RE
+{
+	class __declspec(novtable) ApplyChangesFunctor :
+		public BGSInventoryItem::StackDataWriteFunctor  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::__ApplyChangesFunctor };
+		static constexpr auto VTABLE{ VTABLE::__ApplyChangesFunctor };
+
+		// override
+		virtual void WriteDataImpl(TESBoundObject& a_baseObj, BGSInventoryItem::Stack& a_stack) override  // 01
+		{
+			using func_t = decltype(&ApplyChangesFunctor::WriteDataImpl);
+			static REL::Relocation<func_t> func{ ID::ApplyChangesFunctor::WriteDataImpl };
+			return func(this, a_baseObj, a_stack);
+		}
+
+		// members
+		BGSObjectInstanceExtra*        extra;             // 10
+		TESBoundObject*                object;            // 18
+		const BGSMod::Attachment::Mod* mod;               // 20
+		std::uint8_t                   rank;              // 28
+		bool                           remove;            // 29
+		bool                           excludeTemporary;  // 2A
+		std::int8_t                    favoriteIndex;     // 2B
+	};
+	static_assert(sizeof(ApplyChangesFunctor) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/A/ApplyColorUpdateEvent.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class ApplyColorUpdateEvent
+	{
+	private:
+		using EventSource_t = BSTGlobalEvent::EventSource<ApplyColorUpdateEvent>;
+
+	public:
+		[[nodiscard]] static EventSource_t* GetEventSource()
+		{
+			static REL::Relocation<EventSource_t**> singleton{ ID::ApplyColorUpdateEvent::GetEventSource };
+			if (!*singleton) {
+				*singleton = new EventSource_t(&BSTGlobalEvent::GetSingleton()->eventSourceSDMKiller);
+			}
+			return *singleton;
+		}
+	};
+	static_assert(std::is_empty_v<ApplyColorUpdateEvent>);
+}

plugin/lib/commonlibf4/include/RE/A/ArrowProjectile.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/M/MissileProjectile.h"
+
+namespace RE
+{
+	class __declspec(novtable) ArrowProjectile :
+		public MissileProjectile  // 000
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ArrowProjectile };
+		static constexpr auto VTABLE{ VTABLE::ArrowProjectile };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kPARW };
+
+		// members
+		AlchemyItem* poison;  // 2C0
+	};
+	static_assert(sizeof(ArrowProjectile) == 0x2D0);
+}

plugin/lib/commonlibf4/include/RE/A/AttachTechniqueInput.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class NiAVObject;
+	class NiNode;
+
+	namespace BSAttachTechniques
+	{
+		class __declspec(novtable) AttachTechniqueInput
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::BSAttachTechniques__AttachTechniqueInput };
+			static constexpr auto VTABLE{ VTABLE::BSAttachTechniques__AttachTechniqueInput };
+
+			virtual ~AttachTechniqueInput();  // 00
+
+			// add
+			virtual void Clear();  // 01
+
+			// members
+			NiPointer<NiNode>     root;         // 08
+			NiPointer<NiAVObject> attaching;    // 10
+			std::uint32_t         attachPoint;  // 18
+		};
+		static_assert(sizeof(AttachTechniqueInput) == 0x20);
+	}
+}

plugin/lib/commonlibf4/include/RE/A/AttackBlockHandler.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/H/HeldStateHandler.h"
+#include "RE/S/Setting.h"
+
+namespace RE
+{
+	class AttackBlockHandler :
+		public HeldStateHandler
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::AttackBlockHandler };
+		static constexpr auto VTABLE{ VTABLE::AttackBlockHandler };
+
+		enum class POWER_ATTACK_STATE
+		{
+			kNone = 0,
+			kLeft,
+			kRight,
+			kDual,
+		};
+
+		// members
+		std::uint64_t                                    dualAttackStartTime;         // 28
+		BSFixedString                                    debounceEvent;               // 30
+		REX::TEnumSet<POWER_ATTACK_STATE, std::uint32_t> checkForPowerAttack;         // 38
+		std::uint32_t                                    numPowerAttacks;             // 3C
+		SettingT<INISettingCollection>*                  initialDelay;                // 40
+		SettingT<INISettingCollection>*                  subsequentDelay;             // 48
+		float                                            attackTimer;                 // 50
+		std::uint64_t                                    rightAttackTimestamp;        // 58
+		float                                            rightAttackHeldSeconds;      // 60
+		float                                            rightAttackLastHeldSeconds;  // 64
+		float                                            rightAttackLatchEngage;      // 68
+		float                                            rightAttackLatchRelease;     // 6C
+		bool                                             debounce;                    // 70
+		bool                                             castAttemptMade;             // 71
+		bool                                             leftAttackButtonHeld;        // 72
+		bool                                             rightAttackButtonHeld;       // 73
+		bool                                             rightAttackQueued;           // 74
+		bool                                             rightAttackPrevFrame;        // 75
+		bool                                             setAttackTimer;              // 76
+		bool                                             checkPostMeleeActions;       // 77
+		bool                                             checkPostThrowActions;       // 78
+	};
+	static_assert(sizeof(AttackBlockHandler) == 0x80);
+}

plugin/lib/commonlibf4/include/RE/A/AttackData.h

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace RE
+{
+	class AttackData
+	{
+	public:
+		// members
+		float         damageMult;        // 00
+		float         attackChance;      // 04
+		SpellItem*    attackSpell;       // 08
+		std::uint32_t flags;             // 10
+		float         attackAngle;       // 14
+		float         strikeAngle;       // 18
+		std::int32_t  staggerOffset;     // 1C
+		BGSKeyword*   attackType;        // 20
+		float         knockdown;         // 28
+		float         recoveryTime;      // 2C
+		float         actionPointsMult;  // 30
+	};
+	static_assert(sizeof(AttackData) == 0x38);
+}

plugin/lib/commonlibf4/include/RE/A/AutoMoveHandler.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/P/PlayerInputHandler.h"
+
+namespace RE
+{
+	class AutoMoveHandler :
+		public PlayerInputHandler
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::AutoMoveHandler };
+		static constexpr auto VTABLE{ VTABLE::AutoMoveHandler };
+
+		explicit constexpr AutoMoveHandler(PlayerControlsData& a_data) noexcept :
+			PlayerInputHandler(a_data)
+		{}
+	};
+	static_assert(sizeof(AutoMoveHandler) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/A/AvoidAreaStruct.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSPathingAvoidNode.h"
+
+namespace RE
+{
+	class TESObjectREFR;
+
+	class AvoidAreaStruct
+	{
+	public:
+		// members
+		BSPathingAvoidNode avoideNode;  // 00
+		float              timeExpire;  // 24
+		TESObjectREFR*     refObj;      // 28
+		AvoidAreaStruct*   next;        // 30
+	};
+	static_assert(sizeof(AvoidAreaStruct) == 0x38);
+}