diff --git a/include/RE/B/BGSAssociationType.h b/include/RE/B/BGSAssociationType.h
index ed71c3bf..1a73c948 100644
--- a/include/RE/B/BGSAssociationType.h
+++ b/include/RE/B/BGSAssociationType.h
@@ -13,9 +13,21 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::BGSAssociationType };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kASTP };
 
+		enum class Member
+		{
+			kParent = 0x0,
+			kChild = 0x1,
+			kCount = 0x2
+		};
+
+		enum class Flags
+		{
+			kFamily = 0x1
+		};
+
 		// members
-		BSFixedStringCS associationLabel[2][2];  // 20
-		std::uint32_t   flags;                   // 40
+		BSFixedStringCS                    associationLabel[2][2];  // 20
+		REX::EnumSet<Flags, std::uint32_t> flags;                   // 40
 	};
 	static_assert(sizeof(BGSAssociationType) == 0x48);
 }
diff --git a/include/RE/B/BGSCharacterMorph.h b/include/RE/B/BGSCharacterMorph.h
index e259a20b..ce8b7545 100644
--- a/include/RE/B/BGSCharacterMorph.h
+++ b/include/RE/B/BGSCharacterMorph.h
@@ -112,5 +112,18 @@ namespace RE
 			kLowerTorso = 0x3,
 			kLegs = 0x4
 		};
+
+		enum class Axis : std::uint32_t
+		{
+			kPosX = 0x0,
+			kPosY = 0x1,
+			kPosZ = 0x2,
+			kRotX = 0x3,
+			kRotY = 0x4,
+			kRotZ = 0x5,
+			kScaleX = 0x6,
+			kScaleY = 0x7,
+			kScaleZ = 0x8
+		};
 	}
 }
diff --git a/include/RE/B/BGSConstructibleObject.h b/include/RE/B/BGSConstructibleObject.h
index 7c13ccd9..4fba545c 100644
--- a/include/RE/B/BGSConstructibleObject.h
+++ b/include/RE/B/BGSConstructibleObject.h
@@ -33,6 +33,13 @@ namespace RE
 		[[nodiscard]] TESForm*      GetCreatedItem() const noexcept { return createdItem; }
 		[[nodiscard]] std::uint16_t GetWorkshopPriority() const noexcept { return data.workshopPriority; }
 
+		bool PlayerPassesConditions()
+		{
+			using func_t = decltype(&BGSConstructibleObject::PlayerPassesConditions);
+			static REL::Relocation<func_t> func{ ID::BGSConstructibleObject::PlayerPassesConditions };
+			return func(this);
+		}
+
 		// members
 		BSTArray<BSTTuple<TESForm*, BGSTypedFormValuePair::SharedVal>>* requiredItems;   // 50
 		TESCondition                                                    conditions;      // 58
diff --git a/include/RE/B/BGSDecalEmitter.h b/include/RE/B/BGSDecalEmitter.h
new file mode 100644
index 00000000..999568d2
--- /dev/null
+++ b/include/RE/B/BGSDecalEmitter.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class BGSImpactData;
+	class BSTempEffectParticle;
+
+	class BGSDecalEmitter
+	{
+	public:
+		// members
+		std::int32_t                    decalsToEmit;     // 00
+		bool                            finished;         // 04
+		BGSImpactData*                  decalImpactData;  // 08
+		NiPointer<BSTempEffectParticle> particleData;     // 10
+	};
+	static_assert(sizeof(BGSDecalEmitter) == 0x18);
+}
diff --git a/include/RE/B/BGSDecalGroup.h b/include/RE/B/BGSDecalGroup.h
new file mode 100644
index 00000000..d0843554
--- /dev/null
+++ b/include/RE/B/BGSDecalGroup.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	class DECAL_CREATION_DATA;
+
+	class BGSDecalGroup
+	{
+	public:
+		// members
+		bool                           permanentGroup;  // 00
+		bool                           manualSaveLoad;  // 01
+		BSTArray<std::uint32_t>        decalGroup;      // 08
+		BSTArray<DECAL_CREATION_DATA*> pendingDecals;   // 20
+	};
+	static_assert(sizeof(BGSDecalGroup) == 0x38);
+}
diff --git a/include/RE/B/BGSLOSData.h b/include/RE/B/BGSLOSData.h
new file mode 100644
index 00000000..753521b1
--- /dev/null
+++ b/include/RE/B/BGSLOSData.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/N/NiRefObject.h"
+
+namespace RE
+{
+	class __declspec(novtable) BGSLOSData :
+		public NiRefObject  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BGSLOSData };
+		static constexpr auto VTABLE{ VTABLE::BGSLOSData };
+
+		// members
+		std::uint8_t*  losData;              // 10
+		std::uint16_t* quadGridOffsetArray;  // 18
+		std::uint32_t  losDataSize;          // 20
+		std::uint16_t  indexCount;           // 24
+	};
+	static_assert(sizeof(BGSLOSData) == 0x28);
+}
diff --git a/include/RE/B/BGSLocAlias.h b/include/RE/B/BGSLocAlias.h
new file mode 100644
index 00000000..190afa35
--- /dev/null
+++ b/include/RE/B/BGSLocAlias.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "RE/B/BGSBaseAlias.h"
+
+namespace RE
+{
+	class BGSKeyword;
+	class BGSLocation;
+	class TESCondition;
+	class TESQuest;
+
+	class __declspec(novtable) BGSLocAlias :
+		public BGSBaseAlias  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BGSLocAlias };
+		static constexpr auto VTABLE{ VTABLE::BGSLocAlias };
+
+		// members
+		BGSLocation*  forcedLoc;              // 28
+		BGSKeyword*   forcedFromAliasFilter;  // 30
+		TESQuest*     externalQuest;          // 38
+		TESCondition* conditions;             // 40
+		std::uint32_t forcedFromAlias;        // 48
+		std::uint32_t forcedFromEvent;        // 4C
+		std::uint32_t forcedEventData;        // 50
+		std::uint32_t externalAlias;          // 54
+		std::uint32_t closestToAlias;         // 58
+	};
+	static_assert(sizeof(BGSLocAlias) == 0x60);
+}
diff --git a/include/RE/B/BGSQuestObjective.h b/include/RE/B/BGSQuestObjective.h
new file mode 100644
index 00000000..092e49e5
--- /dev/null
+++ b/include/RE/B/BGSQuestObjective.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BGSLocalizedString.h"
+
+namespace RE
+{
+	class TESQuest;
+	class TESQuestTarget;
+
+	class BGSQuestObjective
+	{
+	public:
+		// members
+		BGSLocalizedString displayText;  // 00
+		TESQuest*          ownerQuest;   // 08
+		TESQuestTarget**   targets;      // 10
+		std::uint32_t      numTargets;   // 18
+		std::uint16_t      index;        // 1C
+		bool               initialized;  // 1E
+		char               state;        // 1F
+		std::uint32_t      flags;        // 20
+	};
+	static_assert(sizeof(BGSQuestObjective) == 0x28);
+}
diff --git a/include/RE/B/BGSTerminal.h b/include/RE/B/BGSTerminal.h
index 34ca0662..dc5e6817 100644
--- a/include/RE/B/BGSTerminal.h
+++ b/include/RE/B/BGSTerminal.h
@@ -30,6 +30,16 @@ namespace RE
 		class MenuItem
 		{
 		public:
+			enum class Flag
+			{
+				kBackToTop = 0x0,
+				kRedraw = 0x1,
+				kSubmenu = 0x2,
+				kText = 0x3,
+				kImage = 0x4,
+				kHolotape = 0x5
+			};
+
 			union USelectionResult
 			{
 				BGSTerminal*        subMenu;
@@ -40,12 +50,12 @@ namespace RE
 			static_assert(sizeof(USelectionResult) == 0x8);
 
 			// members
-			BGSLocalizedString itemText;         // 00
-			BGSLocalizedString responseText;     // 08
-			USelectionResult   selectionResult;  // 10
-			TESCondition       conditions;       // 18
-			std::uint16_t      id;               // 20
-			std::int8_t        flags;            // 22
+			BGSLocalizedString              itemText;         // 00
+			BGSLocalizedString              responseText;     // 08
+			USelectionResult                selectionResult;  // 10
+			TESCondition                    conditions;       // 18
+			std::uint16_t                   id;               // 20
+			REX::EnumSet<Flag, std::int8_t> flags;            // 22
 		};
 		static_assert(sizeof(MenuItem) == 0x28);
 
diff --git a/include/RE/B/BSIMusicTrack.h b/include/RE/B/BSIMusicTrack.h
index 1e23104c..8a92d273 100644
--- a/include/RE/B/BSIMusicTrack.h
+++ b/include/RE/B/BSIMusicTrack.h
@@ -8,7 +8,14 @@ namespace RE
 		static constexpr auto RTTI{ RTTI::BSIMusicTrack };
 		static constexpr auto VTABLE{ VTABLE::BSIMusicTrack };
 
-		enum class MUSIC_STATUS;
+		enum class MUSIC_STATUS
+		{
+			kInactive = 0x0,
+			kPlaying = 0x1,
+			kPaused = 0x2,
+			kFinishing = 0x3,
+			kFinished = 0x4
+		};
 
 		virtual ~BSIMusicTrack() = default;  // 00
 
diff --git a/include/RE/B/BSPathingGoal.h b/include/RE/B/BSPathingGoal.h
new file mode 100644
index 00000000..f84368f2
--- /dev/null
+++ b/include/RE/B/BSPathingGoal.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RE/B/BSPathingLocation.h"
+#include "RE/N/NiPoint.h"
+
+namespace RE
+{
+	class BSPathingGoal
+	{
+	public:
+		enum class GOAL_RADIUS_TYPE
+		{
+			kNone = 0x0,
+			kSoft = 0x1,
+			kHard = 0x2,
+			kMask = 0x3
+		};
+
+		enum class GOAL_HEIGHT_TYPE
+		{
+			kNone = 0x0,
+			kFixed = 0x10,
+			kMask = 0x10
+		};
+
+		// members
+		NiPoint3          targetPoint;            // 00
+		float             targetAngleTolerance;   // 0C
+		BSPathingLocation location;               // 10
+		float             zDelta;                 // 40
+		float             goalRadius;             // 44
+		float             normalizedSpeedAtGoal;  // 48
+	};
+	static_assert(sizeof(BSPathingGoal) == 0x50);
+}
diff --git a/include/RE/B/BSPathingLocation.h b/include/RE/B/BSPathingLocation.h
index f2d2fd00..f48d8d90 100644
--- a/include/RE/B/BSPathingLocation.h
+++ b/include/RE/B/BSPathingLocation.h
@@ -7,7 +7,6 @@
 namespace RE
 {
 	class BSNavmeshInfo;
-	class BSPatchingCell;
 
 	class BSPathingLocation
 	{
diff --git a/include/RE/B/BSPathingStart.h b/include/RE/B/BSPathingStart.h
new file mode 100644
index 00000000..76fb8c66
--- /dev/null
+++ b/include/RE/B/BSPathingStart.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RE/B/BSPathingLocation.h"
+
+namespace RE
+{
+	class BSPathingStart
+	{
+	public:
+		enum class START_TANGENT_TYPE
+		{
+			kNone = 0x0,
+			kSet = 0x1,
+			kKeep = 0x2,
+			kMask = 0x3
+		};
+
+		enum class FLAGS
+		{
+			kSelected = 0x0,
+			kStartsMoving = 0x1
+		};
+
+		// members
+		BSPathingLocation location;  // 00
+		float             tangent;   // 30
+	};
+	static_assert(sizeof(BSPathingStart) == 0x38);
+}
diff --git a/include/RE/B/BSRandom.h b/include/RE/B/BSRandom.h
index b418ad9b..a58b115d 100644
--- a/include/RE/B/BSRandom.h
+++ b/include/RE/B/BSRandom.h
@@ -24,5 +24,12 @@ namespace RE
 			static REL::Relocation<func_t> func{ ID::BSRandom::Float0To1 };
 			return func();
 		}
+
+		inline std::int32_t Int(std::int32_t a_min, std::int32_t a_max)
+		{
+			using func_t = decltype(&BSRandom::Int);
+			static REL::Relocation<func_t> func{ ID::BSRandom::Int };
+			return func(a_min, a_max);
+		}
 	}
 }
diff --git a/include/RE/B/BSUtilities.h b/include/RE/B/BSUtilities.h
index 7414b617..1821ff03 100644
--- a/include/RE/B/BSUtilities.h
+++ b/include/RE/B/BSUtilities.h
@@ -4,29 +4,37 @@
 
 namespace RE
 {
+	class BSFlattenedBoneTree;
 	class NiAVObject;
 
 	namespace BSUtilities
 	{
 		inline std::uint16_t ConvertFloatToHalf(float a_value)
 		{
-			using func_t = decltype(&ConvertFloatToHalf);
+			using func_t = decltype(&BSUtilities::ConvertFloatToHalf);
 			static REL::Relocation<func_t> func{ ID::BSUtilities::ConvertFloatToHalf };
 			return func(a_value);
 		}
 
 		inline float ConvertHalfToFloat(std::uint16_t a_value)
 		{
-			using func_t = decltype(&ConvertHalfToFloat);
+			using func_t = decltype(&BSUtilities::ConvertHalfToFloat);
 			static REL::Relocation<func_t> func{ ID::BSUtilities::ConvertHalfToFloat };
 			return func(a_value);
 		}
 
 		inline NiAVObject* GetObjectByName(NiAVObject* a_root, const BSFixedString& a_name, bool a_tryInternal, bool a_dontAttach)
 		{
-			using func_t = decltype(&GetObjectByName);
+			using func_t = decltype(&BSUtilities::GetObjectByName);
 			static REL::Relocation<func_t> func{ ID::BSUtilities::GetObjectByName };
 			return func(a_root, a_name, a_tryInternal, a_dontAttach);
 		}
+
+		inline BSFlattenedBoneTree* GetFlattenedBoneTree(NiAVObject* a_root)
+		{
+			using func_t = decltype(&BSUtilities::GetFlattenedBoneTree);
+			static REL::Relocation<func_t> func{ ID::BSUtilities::GetFlattenedBoneTree };
+			return func(a_root);
+		}
 	}
 }
diff --git a/include/RE/B/BaseTreeData.h b/include/RE/B/BaseTreeData.h
new file mode 100644
index 00000000..cd6616cf
--- /dev/null
+++ b/include/RE/B/BaseTreeData.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BoneData.h"
+#include "RE/N/NiMatrix3.h"
+
+namespace RE
+{
+	class BaseTreeData :
+		public BSIntrusiveRefCounted  // 00
+	{
+	public:
+		// members
+		BSTArray<BoneData>  branchBoneData;            // 08
+		BSTArray<NiMatrix3> parentWorldBoneRotations;  // 20
+	};
+	static_assert(sizeof(BaseTreeData) == 0x38);
+}
diff --git a/include/RE/C/CombatUtilities.h b/include/RE/C/CombatUtilities.h
index ebba9369..4fcb46de 100644
--- a/include/RE/C/CombatUtilities.h
+++ b/include/RE/C/CombatUtilities.h
@@ -38,11 +38,25 @@ namespace RE
 			float           a_heading,
 			NiPoint3&       a_trajectoryPos)
 		{
-			using func_t = decltype(&CalculateProjectileTrajectory);
+			using func_t = decltype(&CombatUtilities::CalculateProjectileTrajectory);
 			static REL::Relocation<func_t> func{ ID::CombatUtilities::CalculateProjectileTrajectory };
 			return func(a_projectilePos, a_projectileVelocity, a_projectileGravity, a_targetPos, a_heading, a_trajectoryPos);
 		}
 
 		inline static REL::Relocation<float> fWorldGravity{ ID::CombatUtilities::WorldGravity };
+
+		inline bool IsActorUsingMelee(Actor* a_actor)
+		{
+			using func_t = decltype(CombatUtilities::IsActorUsingMelee);
+			static REL::Relocation<func_t> func{ ID::CombatUtilities::IsActorUsingMelee };
+			return func(a_actor);
+		}
+
+		inline bool IsActorUsingUnarmed(Actor* a_actor)
+		{
+			using func_t = decltype(CombatUtilities::IsActorUsingUnarmed);
+			static REL::Relocation<func_t> func{ ID::CombatUtilities::IsActorUsingUnarmed };
+			return func(a_actor);
+		}
 	}
 }
diff --git a/include/RE/C/CountdownTimer.h b/include/RE/C/CountdownTimer.h
new file mode 100644
index 00000000..4a8e3998
--- /dev/null
+++ b/include/RE/C/CountdownTimer.h
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	class CountdownTimer
+	{
+	public:
+		// members
+		std::uint64_t startTime;  // 00
+		std::uint64_t endTime;    // 08
+		bool          isActive;   // 10
+	};
+	static_assert(sizeof(CountdownTimer) == 0x18);
+}
diff --git a/include/RE/D/DECAL_CREATION_DATA.h b/include/RE/D/DECAL_CREATION_DATA.h
new file mode 100644
index 00000000..439ca0c2
--- /dev/null
+++ b/include/RE/D/DECAL_CREATION_DATA.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/N/NiColor.h"
+#include "RE/N/NiMatrix3.h"
+#include "RE/N/NiPoint.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class BGSTextureSet;
+	class NiAVObject;
+	class NiNode;
+	class TESObjectCELL;
+
+	class DECAL_CREATION_DATA
+	{
+	public:
+		// members
+		NiMatrix3             projection;                  // 00
+		NiPoint3A             origin;                      // 30
+		NiPoint3A             direction;                   // 40
+		NiPoint3A             surfaceNormal;               // 50
+		ObjectRefHandle       objRef;                      // 60
+		NiPointer<NiAVObject> avObj;                       // 68
+		NiNode*               clone;                       // 70
+		BGSTextureSet*        texSet;                      // 78
+		BGSTextureSet*        texSet2;                     // 80
+		std::int32_t          index;                       // 88
+		float                 decalWidth;                  // 8C
+		float                 decalHeight;                 // 90
+		float                 decalDepth;                  // 94
+		TESObjectCELL*        parentCell;                  // 98
+		float                 parallaxOcclusionScale;      // A0
+		NiNode*               skinnedDecalNode;            // A8
+		float                 specular;                    // B0
+		float                 decalEpsilon;                // B4
+		float                 placementRadius;             // 0B8
+		NiColor               vertexColor;                 // BC
+		std::uint32_t         bodyParts;                   // C8
+		std::uint8_t          subTex;                      // CC
+		bool                  permanent;                   // CD
+		bool                  parallaxOcclusionShadows;    // CE
+		bool                  alphaTesting;                // CF
+		bool                  alphaBlending;               // D0
+		bool                  multiplicativeBlending;      // D1
+		std::uint8_t          parallaxOcclusionMaxPasses;  // D2
+		bool                  modelSpace;                  // D3
+		bool                  forceFade;                   // D4
+		bool                  twoSided;                    // D5
+		bool                  preprocessed;                // D6
+		bool                  manualSaveLoad;              // D7
+		std::uint32_t         sceneGraphIndex;             // D8
+		float                 decalLifetime;               // DC
+		bool                  dynamic;                     // E0
+		bool                  useGbufferNormal;            // E1
+	};
+	static_assert(sizeof(DECAL_CREATION_DATA) == 0xF0);
+}
diff --git a/include/RE/D/DeferredHideLimb.h b/include/RE/D/DeferredHideLimb.h
index c29140dc..cf2a4abf 100644
--- a/include/RE/D/DeferredHideLimb.h
+++ b/include/RE/D/DeferredHideLimb.h
@@ -11,12 +11,12 @@ namespace RE
 	{
 	public:
 		// members
-		float                      dismemberTimer;       // 00
-		BGSBodyPartDefs::LIMB_ENUM limbIndex;            // 04
-		NiPointer<NiNode>          dismemberedLimbRoot;  // 08
-		NiPointer<NiNode>          replacementLimb;      // 10
-		DeferredHideLimb*          next;                 // 18
-		bool                       explosion;            // 20
+		float                                                   dismemberTimer;       // 00
+		REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::uint32_t> limbIndex;            // 04
+		NiPointer<NiNode>                                       dismemberedLimbRoot;  // 08
+		NiPointer<NiNode>                                       replacementLimb;      // 10
+		DeferredHideLimb*                                       next;                 // 18
+		bool                                                    explosion;            // 20
 	};
 	static_assert(sizeof(DeferredHideLimb) == 0x28);
 }
diff --git a/include/RE/Fallout.h b/include/RE/Fallout.h
index d5046335..eb41a166 100644
--- a/include/RE/Fallout.h
+++ b/include/RE/Fallout.h
@@ -100,6 +100,8 @@
 #include "RE/B/BGSCreatedObjectManager.h"
 #include "RE/B/BGSDamageType.h"
 #include "RE/B/BGSDebris.h"
+#include "RE/B/BGSDecalEmitter.h"
+#include "RE/B/BGSDecalGroup.h"
 #include "RE/B/BGSDecalNode.h"
 #include "RE/B/BGSDefaultObject.h"
 #include "RE/B/BGSDefaultObjectManager.h"
@@ -139,11 +141,13 @@
 #include "RE/B/BGSInventoryListEvent.h"
 #include "RE/B/BGSKeyword.h"
 #include "RE/B/BGSKeywordForm.h"
+#include "RE/B/BGSLOSData.h"
 #include "RE/B/BGSLargeRefData.h"
 #include "RE/B/BGSLensFlare.h"
 #include "RE/B/BGSLightingTemplate.h"
 #include "RE/B/BGSListForm.h"
 #include "RE/B/BGSLoadGameBuffer.h"
+#include "RE/B/BGSLocAlias.h"
 #include "RE/B/BGSLocalizedString.h"
 #include "RE/B/BGSLocation.h"
 #include "RE/B/BGSLocationRefType.h"
@@ -181,6 +185,7 @@
 #include "RE/B/BGSProjectileData.h"
 #include "RE/B/BGSPropertySheet.h"
 #include "RE/B/BGSQuestInstanceText.h"
+#include "RE/B/BGSQuestObjective.h"
 #include "RE/B/BGSRefAlias.h"
 #include "RE/B/BGSRefAliasInstanceData.h"
 #include "RE/B/BGSReferenceEffect.h"
@@ -324,7 +329,9 @@
 #include "RE/B/BSPackedTaskQueue.h"
 #include "RE/B/BSPathingAvoidNode.h"
 #include "RE/B/BSPathingFaceTarget.h"
+#include "RE/B/BSPathingGoal.h"
 #include "RE/B/BSPathingLocation.h"
+#include "RE/B/BSPathingStart.h"
 #include "RE/B/BSPointerAllocator.h"
 #include "RE/B/BSPointerHandle.h"
 #include "RE/B/BSPortal.h"
@@ -499,6 +506,7 @@
 #include "RE/B/BaseExtraList.h"
 #include "RE/B/BaseFormComponent.h"
 #include "RE/B/BaseLoadedInventoryModel.h"
+#include "RE/B/BaseTreeData.h"
 #include "RE/B/BeamProjectile.h"
 #include "RE/B/BipedAnim.h"
 #include "RE/B/Bleedout.h"
@@ -568,6 +576,7 @@
 #include "RE/C/ContainerMenuBase.h"
 #include "RE/C/ContainerObject.h"
 #include "RE/C/ControlMap.h"
+#include "RE/C/CountdownTimer.h"
 #include "RE/C/CreateGrassParams.h"
 #include "RE/C/CreatureSounds.h"
 #include "RE/C/CrimeGoldStruct.h"
@@ -578,6 +587,7 @@
 #include "RE/C/CursorMenu.h"
 #include "RE/C/CursorMoveEvent.h"
 #include "RE/C/CustomMarkerUpdate.h"
+#include "RE/D/DECAL_CREATION_DATA.h"
 #include "RE/D/DECAL_DATA_DATA.h"
 #include "RE/D/DEFAULT_OBJECT.h"
 #include "RE/D/DEFAULT_OBJECT_DATA.h"
@@ -703,6 +713,7 @@
 #include "RE/H/HUDModeInitParams.h"
 #include "RE/H/HUDModeType.h"
 #include "RE/H/HUDModes.h"
+#include "RE/H/HUDNotificationEvent.h"
 #include "RE/H/HUDPerkVaultBoyData.h"
 #include "RE/H/HUDPerkVaultBoySwfDisplayEvent.h"
 #include "RE/H/HUDSubtitleDisplayData.h"
@@ -858,6 +869,7 @@
 #include "RE/L/LevelIncrease.h"
 #include "RE/L/LipSynchAnim.h"
 #include "RE/L/LoadingMenu.h"
+#include "RE/L/LoadingMenuData.h"
 #include "RE/L/LoadingStatusChanged.h"
 #include "RE/L/LocalMapCameraUpdate.h"
 #include "RE/L/LocationMarkerArrayUpdate.h"
@@ -961,6 +973,8 @@
 #include "RE/N/NiUpdateData.h"
 #include "RE/N/NiVisibleArray.h"
 #include "RE/N/NonMorphFaceManagement.h"
+#include "RE/N/nsHUDNotifications.h"
+#include "RE/N/nsHUDTypes.h"
 #include "RE/N/nsStatsMenuUtils.h"
 #include "RE/O/OBJ_ARMA.h"
 #include "RE/O/OBJ_BOOK.h"
diff --git a/include/RE/G/GamePlayFormulas.h b/include/RE/G/GamePlayFormulas.h
index 43529193..ba8dfb71 100644
--- a/include/RE/G/GamePlayFormulas.h
+++ b/include/RE/G/GamePlayFormulas.h
@@ -61,5 +61,12 @@ namespace RE
 			static REL::Relocation<func_t> func{ ID::GamePlayFormulas::GetHackingWordCount };
 			return func(a_playerIntelligence);
 		}
+
+		inline float GetForceLockChance(float a_playerPerception, std::int32_t a_lockLevel)
+		{
+			using func_t = decltype(&GamePlayFormulas::GetForceLockChance);
+			static REL::Relocation<func_t> func{ ID::GamePlayFormulas::GetForceLockChance };
+			return func(a_playerPerception, a_lockLevel);
+		}
 	}
 }
diff --git a/include/RE/H/HUDNotificationEvent.h b/include/RE/H/HUDNotificationEvent.h
new file mode 100644
index 00000000..fa707786
--- /dev/null
+++ b/include/RE/H/HUDNotificationEvent.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTOptional.h"
+#include "RE/X/XPChangeData.h"
+
+namespace RE
+{
+	class BGSQuestObjective;
+	class MapMarkerData;
+	class TESQuest;
+
+	class HUDNotificationEvent
+	{
+	public:
+		// members
+		BSFixedString             messageType;           // 00
+		BSFixedStringCS           messageTitle;          // 08
+		TESQuest*                 quest;                 // 10
+		BGSQuestObjective*        objective;             // 18
+		const MapMarkerData*      markerData;            // 20
+		BSTOptional<XPChangeData> xpChange;              // 28
+		bool                      suppressNotification;  // 3C
+	};
+	static_assert(sizeof(HUDNotificationEvent) == 0x40);
+}
diff --git a/include/RE/IDs.h b/include/RE/IDs.h
index 28d28ceb..73335c09 100644
--- a/include/RE/IDs.h
+++ b/include/RE/IDs.h
@@ -150,6 +150,11 @@ namespace RE::ID
 		inline constexpr REL::ID SetParentGroupNumber{ 2189125 };
 	}
 
+	namespace BGSConstructibleObject
+	{
+		inline constexpr REL::ID PlayerPassesConditions{ 2197318 };
+	}
+
 	namespace BGSCraftItemEvent
 	{
 		inline constexpr REL::ID EventIndex{ 2663409 };
@@ -565,6 +570,7 @@ namespace RE::ID
 		inline constexpr REL::ID UnsignedInt{ 2267950 };
 		inline constexpr REL::ID Float{ 2267953 };
 		inline constexpr REL::ID Float0To1{ 2267954 };
+		inline constexpr REL::ID Int{ 2267952 };
 	}
 
 	namespace BSResource_Archive2_AsyncReaderStream
@@ -789,6 +795,7 @@ namespace RE::ID
 		inline constexpr REL::ID ConvertFloatToHalf{ 2212098 };
 		inline constexpr REL::ID ConvertHalfToFloat{ 2195843 };
 		inline constexpr REL::ID GetObjectByName{ 2274841 };
+		inline constexpr REL::ID GetFlattenedBoneTree{ 2274858 };
 	}
 
 	namespace Calendar
@@ -835,6 +842,8 @@ namespace RE::ID
 		inline constexpr REL::ID CalculateProjectileLOS2{ 2240616 };
 		inline constexpr REL::ID CalculateProjectileTrajectory{ 2240611 };
 		inline constexpr REL::ID WorldGravity{ 2700340 };
+		inline constexpr REL::ID IsActorUsingMelee{ 2240626 };
+		inline constexpr REL::ID IsActorUsingUnarmed{ 2240625 };
 	}
 
 	namespace ComparisonQualifiers
@@ -995,6 +1004,7 @@ namespace RE::ID
 		inline constexpr REL::ID GetPickBreakSeconds{ 2209084 };
 		inline constexpr REL::ID GetHackingWordCount{ 2209067 };
 		inline constexpr REL::ID CalculateItemValue{ 2209074 };
+		inline constexpr REL::ID GetForceLockChance{ 2209065 };
 	}
 
 	namespace GameScript
@@ -1347,6 +1357,21 @@ namespace RE::ID
 		inline constexpr REL::ID SetAllowDegrade{ 2270148 };
 	}
 
+	namespace nsHUDNotifications
+	{
+		inline constexpr REL::ID IsQuestNotification{ 2222465 };
+		inline constexpr REL::ID IsObjectiveNotification{ 2222466 };
+		inline constexpr REL::ID IsLocationDiscoveredNotification{ 2222467 };
+	}
+
+	namespace nsHUDTypes
+	{
+		namespace NotificationInfo
+		{
+			inline constexpr REL::ID ctor{ 2223292 };
+		}
+	}
+
 	namespace nsStatsMenuUtils
 	{
 		inline constexpr REL::ID GetEffectDisplayInfo{ 2224586 };
@@ -1369,7 +1394,7 @@ namespace RE::ID
 
 	namespace PipboyInventoryData
 	{
-		inline constexpr REL::ID RepopulateItemCardsOnSection{ 2225279 };
+		inline constexpr REL::ID RepopulateItemCardOnSection{ 2225279 };
 		inline constexpr REL::ID PopulateItemCardInfo{ 2225266 };
 		inline constexpr REL::ID AddItemCardInfoEntry{ 2225267 };
 		inline constexpr REL::ID BaseAddItemCardInfoEntry{ 2225270 };
diff --git a/include/RE/L/LoadingMenuData.h b/include/RE/L/LoadingMenuData.h
new file mode 100644
index 00000000..35bc5e65
--- /dev/null
+++ b/include/RE/L/LoadingMenuData.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class BGSLocation;
+
+	class __declspec(novtable) LoadingMenuData :
+		public IUIMessageData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::LoadingMenuData };
+		static constexpr auto VTABLE{ VTABLE::LoadingMenuData };
+
+		// members
+		BSFixedString action;    // 18
+		BGSLocation*  location;  // 20
+		bool          interior;  // 28
+	};
+	static_assert(sizeof(LoadingMenuData) == 0x30);
+}
diff --git a/include/RE/N/nsHUDNotifications.h b/include/RE/N/nsHUDNotifications.h
new file mode 100644
index 00000000..204e6290
--- /dev/null
+++ b/include/RE/N/nsHUDNotifications.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	namespace nsHUDNotifications
+	{
+		[[nodiscard]] inline bool IsQuestNotification(const BSFixedString* a_type)
+		{
+			using func_t = decltype(&nsHUDNotifications::IsQuestNotification);
+			static REL::Relocation<func_t> func{ ID::nsHUDNotifications::IsQuestNotification };
+			return func(a_type);
+		}
+
+		[[nodiscard]] inline bool IsObjectiveNotification(const BSFixedString* a_type)
+		{
+			using func_t = decltype(&nsHUDNotifications::IsObjectiveNotification);
+			static REL::Relocation<func_t> func{ ID::nsHUDNotifications::IsObjectiveNotification };
+			return func(a_type);
+		}
+
+		[[nodiscard]] inline bool IsLocationDiscoveredNotification(const BSFixedString* a_type)
+		{
+			using func_t = decltype(&nsHUDNotifications::IsLocationDiscoveredNotification);
+			static REL::Relocation<func_t> func{ ID::nsHUDNotifications::IsLocationDiscoveredNotification };
+			return func(a_type);
+		}
+	}
+}
diff --git a/include/RE/N/nsHUDTypes.h b/include/RE/N/nsHUDTypes.h
new file mode 100644
index 00000000..983d60c7
--- /dev/null
+++ b/include/RE/N/nsHUDTypes.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTOptional.h"
+#include "RE/C/CountdownTimer.h"
+#include "RE/X/XPChangeData.h"
+
+namespace RE
+{
+	class TESQuest;
+
+	namespace nsHUDTypes
+	{
+		class ObjectiveData
+		{
+		public:
+			// members
+			BSFixedStringCS objectiveName;   // 00
+			bool            completed;       // 08
+			bool            orWithPrevious;  // 09
+		};
+		static_assert(sizeof(ObjectiveData) == 0x10);
+
+		class NotificationInfo
+		{
+		public:
+			// members
+			BSFixedStringCS                     title;        // 00
+			BSFixedStringCS                     prefix;       // 08
+			BSFixedStringCS                     soundName;    // 10
+			BSTArray<nsHUDTypes::ObjectiveData> objectives;   // 18
+			BSFixedString                       messageType;  // 30
+			TESQuest*                           quest;        // 38
+			CountdownTimer                      waitTime;     // 40
+			BSTOptional<XPChangeData>           xpChange;     // 58
+		};
+		static_assert(sizeof(NotificationInfo) == 0x70);
+	}
+}
diff --git a/include/RE/P/PipboyInventoryData.h b/include/RE/P/PipboyInventoryData.h
index ea4c27ba..31c2058e 100644
--- a/include/RE/P/PipboyInventoryData.h
+++ b/include/RE/P/PipboyInventoryData.h
@@ -194,10 +194,10 @@ namespace RE
 		virtual void DoClearData();          // 0D
 		virtual void DoClearSink();          // 0E
 
-		void RepopulateItemCardsOnSection(ENUM_FORM_ID itemTypeID)
+		void RepopulateItemCardOnSection(ENUM_FORM_ID itemTypeID)
 		{
-			using func_t = decltype(&PipboyInventoryData::RepopulateItemCardsOnSection);
-			static REL::Relocation<func_t> func{ ID::PipboyInventoryData::RepopulateItemCardsOnSection };
+			using func_t = decltype(&PipboyInventoryData::RepopulateItemCardOnSection);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryData::RepopulateItemCardOnSection };
 			return func(this, itemTypeID);
 		}
 
diff --git a/include/RE/P/Projectile.h b/include/RE/P/Projectile.h
index 891a8710..b28da1c3 100644
--- a/include/RE/P/Projectile.h
+++ b/include/RE/P/Projectile.h
@@ -8,6 +8,8 @@
 #include "RE/B/BSTArray.h"
 #include "RE/B/bhkCollisionQueryResultHandle.h"
 #include "RE/C/CELLJobs.h"
+#include "RE/C/CFilter.h"
+#include "RE/H/hknpBodyId.h"
 #include "RE/N/NiPoint.h"
 #include "RE/N/NiPointer.h"
 #include "RE/N/NiTransform.h"
@@ -39,30 +41,44 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::Projectile };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kREFR };
 
-		class ImpactCreation;
+		class ImpactCreation
+		{
+		public:
+			// members
+			NiPoint3A      contactPoint;       // 00
+			NiPoint3A      contactNormal;      // 10
+			TESObjectREFR* collidee;           // 20
+			CFilter        collisionFilter;    // 28
+			hknpBodyId     collisionBodyId;    // 2C
+			std::uint32_t  collisionShapeKey;  // 30
+			bool           spellCast;          // 34
+			bool           backface;           // 35
+			bool           trigger;            // 36
+		};
+		static_assert(sizeof(ImpactCreation) == 0x40);
 
 		class ImpactData
 		{
 		public:
 			// members
-			NiPoint3                                               location;                // 00
-			NiPoint3                                               normal;                  // 0C
-			bhkCollisionQueryResultHandle                          impactDecalQuery;        // 18
-			ObjectRefHandle                                        collidee;                // 20
-			NiPointer<bhkNPCollisionObject>                        colObj;                  // 28
-			BGSMaterialType*                                       materialType;            // 30
-			REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::int32_t> damageLimb;              // 38
-			REX::EnumSet<COL_LAYER, std::int32_t>                  collisionLayer;          // 3C
-			NiPointer<NiNode>                                      closestBone;             // 40
-			REX::EnumSet<ImpactResult, std::int32_t>               resultOverride;          // 48
-			float                                                  decalSize;               // 4C
-			std::uint32_t                                          collisionShapeKey;       // 50
-			std::int16_t                                           targetWorldObjectCount;  // 54
-			std::int16_t                                           targetWorldObjectIndex;  // 56
-			bool                                                   processed;               // 58
-			bool                                                   spellCast;               // 59
-			bool                                                   effectSpawned;           // 5A
-			bool                                                   backface;                // 5B
+			NiPoint3                                                location;                // 00
+			NiPoint3                                                normal;                  // 0C
+			bhkCollisionQueryResultHandle                           impactDecalQuery;        // 18
+			ObjectRefHandle                                         collidee;                // 20
+			NiPointer<bhkNPCollisionObject>                         colObj;                  // 28
+			BGSMaterialType*                                        materialType;            // 30
+			REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::uint32_t> damageLimb;              // 38
+			REX::EnumSet<COL_LAYER, std::int32_t>                   collisionLayer;          // 3C
+			NiPointer<NiNode>                                       closestBone;             // 40
+			REX::EnumSet<ImpactResult, std::int32_t>                resultOverride;          // 48
+			float                                                   decalSize;               // 4C
+			std::uint32_t                                           collisionShapeKey;       // 50
+			std::int16_t                                            targetWorldObjectCount;  // 54
+			std::int16_t                                            targetWorldObjectIndex;  // 56
+			bool                                                    processed;               // 58
+			bool                                                    spellCast;               // 59
+			bool                                                    effectSpawned;           // 5A
+			bool                                                    backface;                // 5B
 		};
 		static_assert(sizeof(ImpactData) == 0x60);
 
@@ -105,46 +121,46 @@ namespace RE
 		virtual bool          ShouldUseDesiredTarget() { return false; }                                                          // E9
 
 		// members
-		BSTArray<ImpactData>                                   impacts;              // 110
-		NiTransform                                            followOffset;         // 130
-		NiPointer<bhkNPCollisionObject>                        collisionObject;      // 170
-		NiPointer<TESObjectREFR>                               droppedRefr;          // 178
-		NiPoint3                                               movementDirection;    // 180
-		NiPoint3                                               velocity;             // 18C
-		NiPointer<NiLight>                                     light;                // 198
-		NiPointer<ActorCause>                                  actorCause;           // 1A0
-		ObjectRefHandle                                        shooter;              // 1A8
-		ObjectRefHandle                                        desiredTarget;        // 1AC
-		BSSoundHandle                                          sndHandle;            // 1B0
-		BSSoundHandle                                          sndCountdown;         // 1B8
-		BGSExplosion*                                          explosion;            // 1C0
-		MagicItem*                                             spell;                // 1C8
-		REX::EnumSet<MagicSystem::CastingSource, std::int32_t> castingSource;        // 1D0
-		EffectSetting*                                         avEffect;             // 1D8
-		NiPointer<QueuedFile>                                  projectileDBFiles;    // 1E0
-		void*                                                  muzzleFlashDBHandle;  // 1E8 - TODO
-		NiPointer<NiNode>                                      muzzleFlashArt;       // 1F0
-		BSMagicShaderParticles*                                particles;            // 1F8
-		REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::int32_t> targetLimb;           // 200
-		NiPointer<NiAVObject>                                  targetLimbObj;        // 208
-		NiAVObject*                                            clonePoolKey;         // 210
-		float                                                  power;                // 218
-		float                                                  speedMult;            // 21C
-		float                                                  range;                // 220
-		float                                                  age;                  // 224
-		float                                                  damage;               // 228
-		float                                                  alpha;                // 22C
-		float                                                  explosionTimer;       // 230
-		float                                                  blinkTimer;           // 234
-		BGSObjectInstanceT<TESObjectWEAP>                      weaponSource;         // 238
-		TESAmmo*                                               ammoSource;           // 248
-		BGSEquipIndex                                          equipIndex;           // 250
-		float                                                  distanceMoved;        // 254
-		float                                                  movementDelta;        // 258
-		float                                                  scale;                // 25C
-		std::uint64_t                                          flags;                // 260
-		bool                                                   artRequested;         // 268
-		bool                                                   animationsLoaded;     // 269
+		BSTArray<ImpactData>                                    impacts;              // 110
+		NiTransform                                             followOffset;         // 130
+		NiPointer<bhkNPCollisionObject>                         collisionObject;      // 170
+		NiPointer<TESObjectREFR>                                droppedRefr;          // 178
+		NiPoint3                                                movementDirection;    // 180
+		NiPoint3                                                velocity;             // 18C
+		NiPointer<NiLight>                                      light;                // 198
+		NiPointer<ActorCause>                                   actorCause;           // 1A0
+		ObjectRefHandle                                         shooter;              // 1A8
+		ObjectRefHandle                                         desiredTarget;        // 1AC
+		BSSoundHandle                                           sndHandle;            // 1B0
+		BSSoundHandle                                           sndCountdown;         // 1B8
+		BGSExplosion*                                           explosion;            // 1C0
+		MagicItem*                                              spell;                // 1C8
+		REX::EnumSet<MagicSystem::CastingSource, std::int32_t>  castingSource;        // 1D0
+		EffectSetting*                                          avEffect;             // 1D8
+		NiPointer<QueuedFile>                                   projectileDBFiles;    // 1E0
+		void*                                                   muzzleFlashDBHandle;  // 1E8 - TODO
+		NiPointer<NiNode>                                       muzzleFlashArt;       // 1F0
+		BSMagicShaderParticles*                                 particles;            // 1F8
+		REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::uint32_t> targetLimb;           // 200
+		NiPointer<NiAVObject>                                   targetLimbObj;        // 208
+		NiAVObject*                                             clonePoolKey;         // 210
+		float                                                   power;                // 218
+		float                                                   speedMult;            // 21C
+		float                                                   range;                // 220
+		float                                                   age;                  // 224
+		float                                                   damage;               // 228
+		float                                                   alpha;                // 22C
+		float                                                   explosionTimer;       // 230
+		float                                                   blinkTimer;           // 234
+		BGSObjectInstanceT<TESObjectWEAP>                       weaponSource;         // 238
+		TESAmmo*                                                ammoSource;           // 248
+		BGSEquipIndex                                           equipIndex;           // 250
+		float                                                   distanceMoved;        // 254
+		float                                                   movementDelta;        // 258
+		float                                                   scale;                // 25C
+		std::uint64_t                                           flags;                // 260
+		bool                                                    artRequested;         // 268
+		bool                                                    animationsLoaded;     // 269
 	};
 	static_assert(sizeof(Projectile) == 0x270);
 }
diff --git a/include/RE/P/ProjectileLaunchData.h b/include/RE/P/ProjectileLaunchData.h
index c02e8de5..989c22fc 100644
--- a/include/RE/P/ProjectileLaunchData.h
+++ b/include/RE/P/ProjectileLaunchData.h
@@ -18,38 +18,38 @@ namespace RE
 	{
 	public:
 		// members
-		NiPoint3                                               origin;                   // 00
-		NiPoint3                                               contactNormal;            // 0C
-		BGSProjectile*                                         projectileBase;           // 18
-		TESObjectREFR*                                         shooter;                  // 20
-		CombatController*                                      shooterCombatController;  // 28
-		BGSObjectInstanceT<TESObjectWEAP>                      fromWeapon;               // 30
-		TESAmmo*                                               fromAmmo;                 // 40
-		BGSEquipIndex                                          equipIndex;               // 48
-		float                                                  zAngle;                   // 4C
-		float                                                  xAngle;                   // 50
-		float                                                  yAngle;                   // 54
-		TESObjectREFR*                                         homingTarget;             // 58
-		TESObjectCELL*                                         parentCell;               // 60
-		MagicItem*                                             spell;                    // 68
-		REX::EnumSet<MagicSystem::CastingSource, std::int32_t> castingSource;            // 70
-		AlchemyItem*                                           poison;                   // 78
-		std::int32_t                                           area;                     // 80
-		float                                                  power;                    // 84
-		float                                                  scale;                    // 88
-		float                                                  coneOfFireRadiusMult;     // 8C
-		REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::int32_t> targetLimb;               // 90
-		bool                                                   alwaysHit;                // 94
-		bool                                                   noDamageOutsideCombat;    // 95
-		bool                                                   autoAim;                  // 96
-		bool                                                   useOrigin;                // 97
-		bool                                                   deferInitialization;      // 98
-		bool                                                   tracer;                   // 99
-		bool                                                   forceConeOfFire;          // 9A
-		bool                                                   intentionalMiss;          // 9B
-		bool                                                   allow3D;                  // 9C
-		bool                                                   penetrates;               // 9D
-		bool                                                   ignoreNearCollisions;     // 9E
+		NiPoint3                                                origin;                   // 00
+		NiPoint3                                                contactNormal;            // 0C
+		BGSProjectile*                                          projectileBase;           // 18
+		TESObjectREFR*                                          shooter;                  // 20
+		CombatController*                                       shooterCombatController;  // 28
+		BGSObjectInstanceT<TESObjectWEAP>                       fromWeapon;               // 30
+		TESAmmo*                                                fromAmmo;                 // 40
+		BGSEquipIndex                                           equipIndex;               // 48
+		float                                                   zAngle;                   // 4C
+		float                                                   xAngle;                   // 50
+		float                                                   yAngle;                   // 54
+		TESObjectREFR*                                          homingTarget;             // 58
+		TESObjectCELL*                                          parentCell;               // 60
+		MagicItem*                                              spell;                    // 68
+		REX::EnumSet<MagicSystem::CastingSource, std::int32_t>  castingSource;            // 70
+		AlchemyItem*                                            poison;                   // 78
+		std::int32_t                                            area;                     // 80
+		float                                                   power;                    // 84
+		float                                                   scale;                    // 88
+		float                                                   coneOfFireRadiusMult;     // 8C
+		REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::uint32_t> targetLimb;               // 90
+		bool                                                    alwaysHit;                // 94
+		bool                                                    noDamageOutsideCombat;    // 95
+		bool                                                    autoAim;                  // 96
+		bool                                                    useOrigin;                // 97
+		bool                                                    deferInitialization;      // 98
+		bool                                                    tracer;                   // 99
+		bool                                                    forceConeOfFire;          // 9A
+		bool                                                    intentionalMiss;          // 9B
+		bool                                                    allow3D;                  // 9C
+		bool                                                    penetrates;               // 9D
+		bool                                                    ignoreNearCollisions;     // 9E
 	};
 	static_assert(sizeof(ProjectileLaunchData) == 0xA0);
 }
diff --git a/include/RE/T/TESLoadScreen.h b/include/RE/T/TESLoadScreen.h
index 4d09dc94..a8bf458c 100644
--- a/include/RE/T/TESLoadScreen.h
+++ b/include/RE/T/TESLoadScreen.h
@@ -3,10 +3,12 @@
 #include "RE/B/BGSLocalizedString.h"
 #include "RE/T/TESCondition.h"
 #include "RE/T/TESForm.h"
+#include "RE/T/TESModel.h"
 
 namespace RE
 {
-	class LoadNIFData;
+	class BGSTransform;
+	class TESBoundObject;
 
 	class __declspec(novtable) TESLoadScreen :
 		public TESForm  // 00
@@ -16,6 +18,18 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::TESLoadScreen };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kLSCR };
 
+		class LoadNIFData
+		{
+		public:
+			// members
+			TESBoundObject* loadNif;                 // 00
+			std::int16_t    rotationConstraints[2];  // 08
+			TESModel        cameraPath;              // 10
+			BGSTransform*   transform;               // 40
+			float           zoomConstraints[2];      // 48
+		};
+		static_assert(sizeof(LoadNIFData) == 0x50);
+
 		// members
 		TESCondition       conditions;   // 20
 		LoadNIFData*       loadNIFData;  // 28
diff --git a/include/RE/T/TESObjectCELL.h b/include/RE/T/TESObjectCELL.h
index 40227d84..80ac1177 100644
--- a/include/RE/T/TESObjectCELL.h
+++ b/include/RE/T/TESObjectCELL.h
@@ -100,6 +100,19 @@ namespace RE
 			kSoundMarker = 0x1
 		};
 
+		class RENDER_DATA
+		{
+		public:
+			// members
+			std::uint32_t geometryCount;       // 00
+			std::uint32_t triangleCount;       // 04
+			std::uint32_t newRenderPassCoutn;  // 08
+			std::uint32_t activeLights;        // 0C
+			std::uint64_t totalTime;           // 10
+			std::uint32_t accumulateTime;      // 18
+		};
+		static_assert(sizeof(RENDER_DATA) == 0x20);
+
 		[[nodiscard]] bhkWorldM* GetbhkWorld() const
 		{
 			using func_t = decltype(&TESObjectCELL::GetbhkWorld);
diff --git a/include/RE/T/TerminalMenu.h b/include/RE/T/TerminalMenu.h
index f1a97582..ed96992a 100644
--- a/include/RE/T/TerminalMenu.h
+++ b/include/RE/T/TerminalMenu.h
@@ -40,8 +40,8 @@ namespace RE
 		{
 		public:
 			// members
-			const void*        menuItem;  // 00 - BGSTerminal::MenuItem*
-			const BGSTerminal* terminal;  // 08
+			const BGSTerminal::MenuItem* menuItem;  // 00
+			const BGSTerminal*           terminal;  // 08
 		};
 		static_assert(sizeof(ListItem) == 0x10);
 
diff --git a/include/RE/V/VATSCommand.h b/include/RE/V/VATSCommand.h
index c6e57333..e628db77 100644
--- a/include/RE/V/VATSCommand.h
+++ b/include/RE/V/VATSCommand.h
@@ -17,19 +17,19 @@ namespace RE
 	{
 	public:
 		// members
-		ActionPoints::Action       action;              // 004
-		ObjectRefHandle            target;              // 008
-		BGSBodyPartDefs::LIMB_ENUM limb;                // 00C
-		NiPointer<NiAVObject>      aimAtObj;            // 010
-		HitData                    hitdata;             // 20
-		SpellItem*                 meleeImpactEffect;   // 100
-		float                      actionPointCost;     // 108
-		float                      minActionTime;       // 10C
-		float                      actionExecuteDelay;  // 110
-		float                      fakeShotFrequency;   // 114
-		float                      damageMult;          //118
-		std::uint32_t              loadedAmmoCount;     // 11C
-		std::uint8_t               fireShots;           // 120
+		ActionPoints::Action                                    action;              // 004
+		ObjectRefHandle                                         target;              // 008
+		REX::EnumSet<BGSBodyPartDefs::LIMB_ENUM, std::uint32_t> limb;                // 00C
+		NiPointer<NiAVObject>                                   aimAtObj;            // 010
+		HitData                                                 hitdata;             // 20
+		SpellItem*                                              meleeImpactEffect;   // 100
+		float                                                   actionPointCost;     // 108
+		float                                                   minActionTime;       // 10C
+		float                                                   actionExecuteDelay;  // 110
+		float                                                   fakeShotFrequency;   // 114
+		float                                                   damageMult;          //118
+		std::uint32_t                                           loadedAmmoCount;     // 11C
+		std::uint8_t                                            fireShots;           // 120
 		struct
 		{
 			std::uint8_t stranger: 1;