diff --git a/CommonLibF4/cmake/sourcelist.cmake b/CommonLibF4/cmake/sourcelist.cmake index 07698bae..5d2bea4e 100644 --- a/CommonLibF4/cmake/sourcelist.cmake +++ b/CommonLibF4/cmake/sourcelist.cmake @@ -10,6 +10,7 @@ set(SOURCES include/RE/Bethesda/AITimeStamp.h include/RE/Bethesda/ActiveEffect.h include/RE/Bethesda/Actor.h + include/RE/Bethesda/ActorUtils.h include/RE/Bethesda/ActorValueInfo.h include/RE/Bethesda/Archive2.h include/RE/Bethesda/Atomic.h @@ -197,10 +198,25 @@ set(SOURCES include/RE/Bethesda/Movement.h include/RE/Bethesda/NavMesh.h include/RE/Bethesda/NavMeshInfoMap.h + include/RE/Bethesda/PipboyArray.h include/RE/Bethesda/PipboyDataGroup.h + include/RE/Bethesda/PipboyDataManager.h + include/RE/Bethesda/PipboyInventoryData.h include/RE/Bethesda/PipboyInventoryUtils.h + include/RE/Bethesda/PipboyLogData.h include/RE/Bethesda/PipboyManager.h + include/RE/Bethesda/PipboyMapData.h + include/RE/Bethesda/PipboyPerksData.h + include/RE/Bethesda/PipboyPlayerInfoData.h + include/RE/Bethesda/PipboyPrimitiveValue.h + include/RE/Bethesda/PipboyQuestData.h + include/RE/Bethesda/PipboyRadioData.h + include/RE/Bethesda/PipboySpecialData.h + include/RE/Bethesda/PipboyStatsData.h + include/RE/Bethesda/PipboyStatusData.h + include/RE/Bethesda/PipboyThrottleManager.h include/RE/Bethesda/PipboyValue.h + include/RE/Bethesda/PipboyWorkshopData.h include/RE/Bethesda/PlayerCharacter.h include/RE/Bethesda/PlayerControls.h include/RE/Bethesda/PowerArmor.h diff --git a/CommonLibF4/include/RE/Bethesda/Actor.h b/CommonLibF4/include/RE/Bethesda/Actor.h index 01a24dc0..fb156727 100644 --- a/CommonLibF4/include/RE/Bethesda/Actor.h +++ b/CommonLibF4/include/RE/Bethesda/Actor.h @@ -20,9 +20,6 @@ namespace RE { - enum class ACTOR_CRITICAL_STAGE; - enum class ACTOR_LIFE_STATE; - enum class ACTOR_LOS_LOCATION; enum class ATTACK_STATE_ENUM; enum class COMMAND_TYPE; enum class DEFAULT_OBJECT; @@ -112,53 +109,89 @@ namespace RE struct PerkEntryUpdatedEvent; } + enum class ACTOR_CRITICAL_STAGE : std::int32_t + { + kNone = 0x0, + kGooStart = 0x1, + kGooEnd = 0x2, + kDisintegrateStart = 0x3, + kDisintegrateEnd = 0x4, + kFreezeStart = 0x5, + kFreezeEnd = 0x6, + kCount = 0x7 + }; + + 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 + }; + + enum class ACTOR_LOS_LOCATION : std::int32_t + { + kNone = 0x0, + kEye = 0x1, + kHead = 0x2, + kTorse = 0x3, + kFeet = 0x4, + kCount = 0x5 + }; + enum class PTYPE : std::int32_t { - kExplore = 0, - kFollow = 1, - kEscore = 2, - kEat = 3, - kSleep = 4, - kWander = 5, - kTravel = 6, - kAccompany = 7, - kUseItemAt = 8, - kAmbush = 9, - kFleeNonCombat = 10, - kCastMagic = 11, - kSandbox = 12, - kPatrol = 13, - kGuard = 14, - kDialogue = 15, - kUseWeapon = 16, - kFind = 17, - kCustom = 18, - kTemplate = 19, - kActivate = 20, - kAlarm = 21, - kFlee = 22, - kTrespass = 23, - kSpectator = 24, - kGreet = 25, - kGetUp = 26, - kDoNothing = 27, - kInGameDialogue = 28, - kSurface = 29, - kSearchForAttacker = 30, - kAvoidReference = 31, - kBumpReaction = 32, - kGrenadeMineReaction = 33, - kStealWarning = 34, - kPickpocketWarning = 35, - kMovementBlocked = 36, - kVampireFeed = 37, - kCannibal = 38, - kLand = 39, - kUnused = 40, - kMountActor = 41, - kDismountActor = 42, - kClearMountPosition = 43, - kClearPowerArmorExit = 44, + kExplore = 0x0, + kFollow = 0x1, + kEscore = 0x2, + kEat = 0x3, + kSleep = 0x4, + kWander = 0x5, + kTravel = 0x6, + kAccompany = 0x7, + kUseItemAt = 0x8, + kAmbush = 0x9, + kFleeNonCombat = 0xA, + kCastMagic = 0xB, + kSandbox = 0xC, + kPatrol = 0xD, + kGuard = 0xE, + kDialogue = 0xF, + kUseWeapon = 0x10, + kFind = 0x11, + kCustom = 0x12, + kTemplate = 0x13, + kActivate = 0x14, + kAlarm = 0x15, + kFlee = 0x16, + kTrespass = 0x17, + kSpectator = 0x18, + kGreet = 0x19, + kGetUp = 0x1A, + kDoNothing = 0x1B, + kInGameDialogue = 0x1C, + kSurface = 0x1D, + kSearchForAttacker = 0x1E, + kAvoidReference = 0x1F, + kBumpReaction = 0x20, + kGrenadeMineReaction = 0x21, + kStealWarning = 0x22, + kPickpocketWarning = 0x23, + kMovementBlocked = 0x24, + kVampireFeed = 0x25, + kCannibal = 0x26, + kLand = 0x27, + kUnused = 0x28, + kMountActor = 0x29, + kDismountActor = 0x2A, + kClearMountPosition = 0x2B, + kClearPowerArmorExit = 0x2C, + kCount = 0x2D }; struct MiddleLowProcessData @@ -490,9 +523,9 @@ namespace RE enum class WEAPON_CULL_TYPE { - kGeneral, - kAnimation, - kWeaponSwitch, + kGeneral = 0x0, + kAnimation = 0x1, + kWeaponSwitch = 0x2, }; class AITimer @@ -537,7 +570,7 @@ namespace RE void KnockExplosion(Actor* a_actor, const NiPoint3& a_location, float a_magnitude) { using func_t = decltype(&AIProcess::KnockExplosion); - static REL::Relocation func{ REL::ID(533106) }; + static REL::Relocation func{ REL::ID(2232384) }; return func(this, a_actor, a_location, a_magnitude); } @@ -556,7 +589,7 @@ namespace RE bool RequestLoadAnimationsForWeaponChange(Actor& a_actor) { using func_t = decltype(&AIProcess::RequestLoadAnimationsForWeaponChange); - static REL::Relocation func{ REL::ID(666002) }; + static REL::Relocation func{ REL::ID(2231758) }; return func(this, a_actor); } @@ -697,46 +730,46 @@ namespace RE enum class LIFE_STATE : std::uint32_t { - kAlive, - kDying, - kDead, - kUnconscious, - kReanimate, - kRecycle, - kRestrained, - kEssentialDown, - kBleedout + kAlive = 0x0, + kDying = 0x1, + kDead = 0x2, + kUnconscious = 0x3, + kReanimate = 0x4, + kRecycle = 0x5, + kRestrained = 0x6, + kEssentialDown = 0x7, + kBleedout = 0x8 }; enum class WEAPON_STATE : std::uint32_t { - kSheathed, - kWantToDraw, - kDrawing, - kDrawn, - kWantToSheathe, - kSheathing + kSheathed = 0x0, + kWantToDraw = 0x1, + kDrawing = 0x2, + kDrawn = 0x3, + kWantToSheathe = 0x4, + kSheathing = 0x5 }; enum class GUN_STATE : std::uint32_t { - kDrawn, - kRelaxed, - kBlocked, - kAlert, - kReloading, - kThrowing, - kSighted, - kFire, - kFireSighted + kDrawn = 0x0, + kRelaxed = 0x1, + kBlocked = 0x2, + kAlert = 0x3, + kReloading = 0x4, + kThrowing = 0x5, + kSighted = 0x6, + kFire = 0x7, + kFireSighted = 0x8 }; enum class INTERACTING_STATE : std::uint32_t { - kNotInteracting, - kWaitingToInteract, - kInteracting, - kWaitingToStopInteracting + kNotInteracting = 0x0, + kWaitingToInteract = 0x1, + kInteracting = 0x2, + kWaitingToStopInteracting = 0x3 }; class __declspec(novtable) ActorState : @@ -881,12 +914,12 @@ namespace RE enum class DETECTION_PRIORITY { - kNone = 0, - kVeryLow = 1, - kLow = 2, - kNormal = 3, - kHigh = 4, - kCritical = 5, + kNone = 0x0, + kVeryLow = 0x1, + kLow = 0x2, + kNormal = 0x3, + kHigh = 0x4, + kCritical = 0x5, }; // add @@ -1265,6 +1298,20 @@ namespace RE return func(this, a_refr, a_owner, a_crime); } + void UpdateVoiceTimer(bool a_force) + { + using func_t = decltype(&Actor::UpdateVoiceTimer); + static REL::Relocation func{ REL::ID(2230178) }; + return func(this, a_force); + } + + BGSBodyPartData* GetBodyPartData() + { + using func_t = decltype(&Actor::GetBodyPartData); + static REL::Relocation func{ REL::ID(2229571) }; + return func(this); + } + // members NiTFlags niFlags; // 2D0 float updateTargetTimer; // 2D4 @@ -1366,6 +1413,13 @@ namespace RE static REL::Relocation func{ REL::ID(2231395) }; 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{ REL::ID(2231399) }; + return func(this, a_actor, a_equippedItem, a_queueEquip); + } }; static_assert(sizeof(ActorEquipManager) == 0x60); } diff --git a/CommonLibF4/include/RE/Bethesda/ActorUtils.h b/CommonLibF4/include/RE/Bethesda/ActorUtils.h new file mode 100644 index 00000000..1dba286a --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/ActorUtils.h @@ -0,0 +1,60 @@ +#pragma once + +#include "RE/Bethesda/TESBoundObjects.h" + +namespace RE +{ + namespace ActorUtils + { + class __declspec(novtable) ArmorRatingVisitorBase + { + public: + static constexpr auto RTTI{ RTTI::ActorUtils__ArmorRatingVisitorBase }; + static constexpr auto VTABLE{ VTABLE::ActorUtils__ArmorRatingVisitorBase }; + + ArmorRatingVisitorBase() + { + stl::emplace_vtable(this); + } + + virtual bool ShouldProcess(TESBoundObject*) { return 1; }; // 00 + virtual void PostPRocess(TESBoundObject*){}; // 01 + + Actor* actor; // 08 + float rating; // 10 + float armorPerks; // 14 + bool checkEquipped; // 18 + + void ctor(const Actor* a_actor, bool a_checkEquipped) + { + using func_t = decltype(&ArmorRatingVisitorBase::ctor); + REL::Relocation func{ REL::ID(2227205) }; + return func(this, a_actor, a_checkEquipped); + } + + ArmorRatingVisitorBase(const Actor* a_actor, bool a_checkEquipped) + { + ctor(a_actor, a_checkEquipped); + } + + std::int64_t operator()(const BGSInventoryItem* a_item, std::uint32_t a_stackID) + { + using func_t = decltype(&ArmorRatingVisitorBase::operator()); + REL::Relocation func{ REL::ID(2227206) }; + return func(this, a_item, a_stackID); + } + }; + static_assert(offsetof(ArmorRatingVisitorBase, rating) == 0x10); + 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 foundArmor; // 20 + }; + static_assert(sizeof(ArmorRatingVisitor) == 0x40); + } +} diff --git a/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h b/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h index 26220a76..c62b7112 100644 --- a/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h +++ b/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h @@ -17,16 +17,16 @@ namespace RE public: enum class AVType { - kDerivedAttribute, - kAttribute, - kSkill, - kAIAttribute, - kResistance, - kCondition, - kCharge, - kIntValue, - kVariable, - kResource + 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 diff --git a/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h b/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h index 0f5db7a4..3aae130f 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h +++ b/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h @@ -73,14 +73,14 @@ namespace RE enum class FILL_TYPE { - kConditions, - kForced, - kFromAlias, - kFromEvent, - kCreated, - kFromExternal, - kUniqueActor, - kNearAlias, + kConditions = 0x0, + kForced = 0x1, + kFromAlias = 0x2, + kFromEvent = 0x3, + kCreated = 0x4, + kFromExternal = 0x5, + kUniqueActor = 0x6, + kNearAlias = 0x7, }; struct GenericFillData diff --git a/CommonLibF4/include/RE/Bethesda/BGSBodyPartDefs.h b/CommonLibF4/include/RE/Bethesda/BGSBodyPartDefs.h index 79792d16..f5604fb4 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSBodyPartDefs.h +++ b/CommonLibF4/include/RE/Bethesda/BGSBodyPartDefs.h @@ -4,6 +4,49 @@ namespace RE::BGSBodyPartDefs { + enum class LIMB_ENUM : std::uint32_t + { + kNone = 0xFFFFFFFF, + kTorso = 0x0, + kHead1 = 0x1, + kEye1 = 0x2, + kLookAt1 = 0x3, + kFlyGrab = 0x4, + kHead2 = 0x5, + kLeftArm1 = 0x6, + kLeftArm2 = 0x7, + kRightArm1 = 0x8, + kRightArm2 = 0x9, + kLeftLeg1 = 0xA, + kLeftLeg2 = 0xB, + kLeftLeg3 = 0xC, + kRightLeg1 = 0xD, + kRightLeg2 = 0xE, + kRightLeg3 = 0xF, + kBrain = 0x10, + kWeapon = 0x11, + kRoot = 0x12, + kCom = 0x13, + kPelvis = 0x14, + kCamera = 0x15, + kOffsetRoot = 0x16, + kLeftFoot = 0x17, + kRightFoot = 0x18, + kFaceTargetSource = 0x19 + }; + + enum class CAUSE_OF_DEATH : std::uint32_t + { + kCauseOfDeathNone = 0xFFFFFFFF, + kCauseOfDeathExplosion = 0x0, + kCauseOfDeathGun = 0x1, + kCauseOfDeathBluntWeapon = 0x2, + kCauseOfDeathHandToHand = 0x3, + kCauseOfDeathObjectImpact = 0x4, + kCauseOfDeathPoison = 0x5, + kCauseOfDeathDecapitation = 0x6 + }; + struct HitReactionData { public: diff --git a/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h b/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h index 57967fc4..063c54d0 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h +++ b/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h @@ -14,12 +14,12 @@ namespace RE { enum BlendOp : std::uint32_t { - kDefault = 0, - kMultiply = 1, - kOverlay = 2, - kSoftLight = 3, - kHardLight = 4, - kTotal = 5 + kDefault = 0x0, + kMultiply = 0x1, + kOverlay = 0x2, + kSoftLight = 0x3, + kHardLight = 0x4, + kTotal = 0x5 }; enum EntryType : std::uint32_t @@ -32,32 +32,32 @@ namespace RE enum class EntrySlot { - kForeheadMask, - kEyesMask, - kNoseMask, - kEarsMask, - kCheeksMask, - kMouthMask, - kNeckMask, - kLipColor, - kCheekColor, - kEyeliner, - kEyeSocketUpper, - kEyeSocketLower, - kSkinTone, - kPaint, - kLaughLines, - kCheekColorLower, - kNose, - kChin, - kNeck, - kForehead, - kDirt, - kScars, - kFaceDetail, - kBrow, - kWrinkles, - kBeard + kForeheadMask = 0x0, + kEyesMask = 0x1, + kNoseMask = 0x2, + kEarsMask = 0x3, + kCheeksMask = 0x4, + kMouthMask = 0x5, + kNeckMask = 0x6, + kLipColor = 0x7, + kCheekColor = 0x8, + kEyeliner = 0x9, + kEyeSocketUpper = 0xA, + kEyeSocketLower = 0xB, + kSkinTone = 0xC, + kPaint = 0xD, + kLaughLines = 0xE, + kCheekColorLower = 0xF, + kNose = 0x10, + kChin = 0x11, + kNeck = 0x12, + kForehead = 0x13, + kDirt = 0x14, + kScars = 0x15, + kFaceDetail = 0x16, + kBrow = 0x17, + kWrinkles = 0x18, + kBeard = 0x19 }; namespace Template diff --git a/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h b/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h index adbaf358..eeeaba23 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h +++ b/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h @@ -8,412 +8,412 @@ namespace RE { enum class DEFAULT_OBJECT { - kSittingAngleLimit = 1, - kAllowPlayerShout, - kGold, - kLockpick, - kSkeletonKey, - kPlayerFaction, - kGuardFaction, - kBattleMusic, - kDeathMusic, - kDungeonClearedMusic, - kPlayerVoiceMale, - kPlayerVoiceMaleChild, - kPlayerVoiceFemale, - kPlayerVoiceFemaleChild, - kEatPackageDefaultFood, - kVoiceEquip, - kPotionEquip, - kEveryActorAbility, - kCommandedActorAbility, - kDrugWearsOffImageSpace, - kFootstepSet, - kLandscapeMaterial, - kDragonLandZoneMarker, - kDragonCrashZoneMarker, - kCombatStyle, - kDefaultPackList, - kWaitForDialoguePackage, - kVirtualLocation, - kPersistAllLocation, - kPathingTestNPC, - kActionSwimStateChange, - kActionLook, - kActionLeftAttack, - kActionLeftReady, - kActionLeftRelease, - kActionLeftInterrupt, - kActionRightAttack, - kActionRightReady, - kActionRightRelease, - kActionRightInterrupt, - kActionDualAttack, - kActionDualRelease, - kActionActivate, - kActionJump, - kActionFall, - kActionLand, - kActionMantle, - kActionSneak, - kActionVoice, - kActionVoiceReady, - kActionVoiceRelease, - kActionVoiceInterrupt, - kActionIdle, - kActionSprintStart, - kActionSprintStop, - kActionDraw, - kActionSheath, - kActionLeftPowerAttack, - kActionRightPowerAttack, - kActionDualPowerAttack, - kActionLeftSyncAttack, - kActionRightSyncAttack, - kActionStaggerStart, - kActionBlockHit, - kActionBlockAnticipate, - kActionRecoil, - kActionLargeRecoil, - kActionBleedoutStart, - kActionBleedoutStop, - kActionIdleStop, - kActionWardHit, - kActionForceEquip, - kActionShieldChange, - kActionPathStart, - kActionPathEnd, - kActionLargeMovementDelta, - kActionFlyStart, - kActionFlyStop, - kActionHoverStart, - kActionHoverStop, - kActionBumpedInto, - kActionSummonedStart, - kActionDialogueTalking, - kActionDialogueListen, - kActionDialogueListenPositive, - kActionDialogueListenNegative, - kActionDialogueListenQuestion, - kActionDialogueListenNeutral, - kActionDialogueEnter, - kActionDialogueExit, - kActionDeath, - kActionDeathWait, - kActionIdleWarn, - kActionMoveStart, - kActionMoveStop, - kActionTurnRight, - kActionTurnLeft, - kActionTurnStop, - kActionMoveForward, - kActionMoveBackward, - kActionMoveLeft, - kActionMoveRight, - kActionKnockdown, - kActionGetUp, - kActionIdleStopInstant, - kActionRagdollInstant, - kActionWaterwalkStart, - kActionReload, - kActionBoltCharge, - kActionSighted, - kActionSightedRelease, - kActionMelee, - kActionFireSingle, - kActionFireCharge, - kActionFireChargeHold, - kActionFireAuto, - kActionFireEmpty, - kActionThrow, - kActionEnterCover, - kActionExitCover, - kActionCoverSprintStart, - kActionShuffle, - kActionPipboy, - kActionPipboyClose, - kActionPipboyZoom, - kActionPipboyStats, - kActionPipboyInventory, - kActionPipboyData, - kActionPipboyMap, - kActionPipboyTab, - kActionPipboyTabPrevious, - kActionPipboySelect, - kActionPipboyRadioOn, - kActionPipboyRadioOff, - kActionPipboyLoadHolotape, - kActionPipboyInspect, - kActionNonSupportContact, - kActionInteractionEnter, - kActionInteractionExit, - kActionInteractionExitAlternate, - kActionInteractionExitQuick, - kActionIntimidate, - kActionGunChargeStart, - kActionGunDown, - kActionGunRelaxed, - kActionGunAlert, - kActionGunReady, - kActionFlipThrow, - kActionEnterCombat, - kActionExitCombat, - kActionLimbCritical, - kActionEvade, - kActionDodge, - kActionAoEAttack, - kActionPanic, - kActionCower, - kActionTunnel, - kActionHide, - kPickupSoundGeneric, - kPutdownSoundGeneric, - kPickupSoundWeapon, - kPutdownSoundWeapon, - kPickupSoundArmor, - kPutdownSoundArmor, - kPickupSoundBook, - kPutdownSoundBook, - kPickupSoundIngredient, - kPutdownSoundIngredient, - kHarvestSound, - kHarvestFailedSound, - kWardBreakSound, - kWardAbsorbSound, - kWardDeflectSound, - kMagicFailSound, - kShoutFailSound, - kHeartbeatSoundFast, - kHeartbeatSoundSlow, - kImagespaceLowHealth, - kSoulCapturedSound, - kNoActivationSound, - kMapMenuLoopingSound, - kDialogueVoiceCategory, - kNonDialogueVoiceCategory, - kSFXToFadeInDialogueCategory, - kPauseDuringMenuCategoryFade, - kPauseDuringMenuCategoryImmediate, - kPauseDuringLoadingMenuCategory, - kMusicSoundCategory, - kStatsMuteCategory, - kStatsMusic, - kMasterSoundCategory, - kDialogueOutputModel3D, - kDialogueOutputModel2D, - kPlayersOutputModel1stPerson, - kPlayersOutputModel3rdPerson, - kInterfaceOutputModel, - kReverbType, - kUnderwaterLoopSound, - kUnderwaterReverbType, - kKeywordHorse, - kKeywordUndead, - kKeywordNPC, + kSittingAngleLimit = 0x1, + kAllowPlayerShout = 0x2, + kGold = 0x3, + kLockpick = 0x4, + kSkeletonKey = 0x5, + kPlayerFaction = 0x6, + kGuardFaction = 0x7, + kBattleMusic = 0x8, + kDeathMusic = 0x9, + kDungeonClearedMusic = 0xA, + kPlayerVoiceMale = 0xB, + kPlayerVoiceMaleChild = 0xC, + kPlayerVoiceFemale = 0xD, + kPlayerVoiceFemaleChild = 0xE, + kEatPackageDefaultFood = 0xF, + kVoiceEquip = 0x10, + kPotionEquip = 0x11, + kEveryActorAbility = 0x12, + kCommandedActorAbility = 0x13, + kDrugWearsOffImageSpace = 0x14, + kFootstepSet = 0x15, + kLandscapeMaterial = 0x16, + kDragonLandZoneMarker = 0x17, + kDragonCrashZoneMarker = 0x18, + kCombatStyle = 0x19, + kDefaultPackList = 0x1A, + kWaitForDialoguePackage = 0x1B, + kVirtualLocation = 0x1C, + kPersistAllLocation = 0x1D, + kPathingTestNPC = 0x1E, + kActionSwimStateChange = 0x1F, + kActionLook = 0x20, + kActionLeftAttack = 0x21, + kActionLeftReady = 0x22, + kActionLeftRelease = 0x23, + kActionLeftInterrupt = 0x24, + kActionRightAttack = 0x25, + kActionRightReady = 0x26, + kActionRightRelease = 0x27, + kActionRightInterrupt = 0x28, + kActionDualAttack = 0x29, + kActionDualRelease = 0x2A, + kActionActivate = 0x2B, + kActionJump = 0x2C, + kActionFall = 0x2D, + kActionLand = 0x2E, + kActionMantle = 0x2F, + kActionSneak = 0x30, + kActionVoice = 0x31, + kActionVoiceReady = 0x32, + kActionVoiceRelease = 0x33, + kActionVoiceInterrupt = 0x34, + kActionIdle = 0x35, + kActionSprintStart = 0x36, + kActionSprintStop = 0x37, + kActionDraw = 0x38, + kActionSheath = 0x39, + kActionLeftPowerAttack = 0x3A, + kActionRightPowerAttack = 0x3B, + kActionDualPowerAttack = 0x3C, + kActionLeftSyncAttack = 0x3D, + kActionRightSyncAttack = 0x3E, + kActionStaggerStart = 0x3F, + kActionBlockHit = 0x40, + kActionBlockAnticipate = 0x41, + kActionRecoil = 0x42, + kActionLargeRecoil = 0x43, + kActionBleedoutStart = 0x44, + kActionBleedoutStop = 0x45, + kActionIdleStop = 0x46, + kActionWardHit = 0x47, + kActionForceEquip = 0x48, + kActionShieldChange = 0x49, + kActionPathStart = 0x4A, + kActionPathEnd = 0x4B, + kActionLargeMovementDelta = 0x4C, + kActionFlyStart = 0x4D, + kActionFlyStop = 0x4E, + kActionHoverStart = 0x4F, + kActionHoverStop = 0x50, + kActionBumpedInto = 0x51, + kActionSummonedStart = 0x52, + kActionDialogueTalking = 0x53, + kActionDialogueListen = 0x54, + kActionDialogueListenPositive = 0x55, + kActionDialogueListenNegative = 0x56, + kActionDialogueListenQuestion = 0x57, + kActionDialogueListenNeutral = 0x58, + kActionDialogueEnter = 0x59, + kActionDialogueExit = 0x5A, + kActionDeath = 0x5B, + kActionDeathWait = 0x5C, + kActionIdleWarn = 0x5D, + kActionMoveStart = 0x5E, + kActionMoveStop = 0x5F, + kActionTurnRight = 0x60, + kActionTurnLeft = 0x61, + kActionTurnStop = 0x62, + kActionMoveForward = 0x63, + kActionMoveBackward = 0x64, + kActionMoveLeft = 0x65, + kActionMoveRight = 0x66, + kActionKnockdown = 0x67, + kActionGetUp = 0x68, + kActionIdleStopInstant = 0x69, + kActionRagdollInstant = 0x6A, + kActionWaterwalkStart = 0x6B, + kActionReload = 0x6C, + kActionBoltCharge = 0x6D, + kActionSighted = 0x6E, + kActionSightedRelease = 0x6F, + kActionMelee = 0x70, + kActionFireSingle = 0x71, + kActionFireCharge = 0x72, + kActionFireChargeHold = 0x73, + kActionFireAuto = 0x74, + kActionFireEmpty = 0x75, + kActionThrow = 0x76, + kActionEnterCover = 0x77, + kActionExitCover = 0x78, + kActionCoverSprintStart = 0x79, + kActionShuffle = 0x7A, + kActionPipboy = 0x7B, + kActionPipboyClose = 0x7C, + kActionPipboyZoom = 0x7D, + kActionPipboyStats = 0x7E, + kActionPipboyInventory = 0x7F, + kActionPipboyData = 0x80, + kActionPipboyMap = 0x81, + kActionPipboyTab = 0x82, + kActionPipboyTabPrevious = 0x83, + kActionPipboySelect = 0x84, + kActionPipboyRadioOn = 0x85, + kActionPipboyRadioOff = 0x86, + kActionPipboyLoadHolotape = 0x87, + kActionPipboyInspect = 0x88, + kActionNonSupportContact = 0x89, + kActionInteractionEnter = 0x8A, + kActionInteractionExit = 0x8B, + kActionInteractionExitAlternate = 0x8C, + kActionInteractionExitQuick = 0x8D, + kActionIntimidate = 0x8E, + kActionGunChargeStart = 0x8F, + kActionGunDown = 0x90, + kActionGunRelaxed = 0x91, + kActionGunAlert = 0x92, + kActionGunReady = 0x93, + kActionFlipThrow = 0x94, + kActionEnterCombat = 0x95, + kActionExitCombat = 0x96, + kActionLimbCritical = 0x97, + kActionEvade = 0x98, + kActionDodge = 0x99, + kActionAoEAttack = 0x9A, + kActionPanic = 0x9B, + kActionCower = 0x9C, + kActionTunnel = 0x9D, + kActionHide = 0x9E, + kPickupSoundGeneric = 0x9F, + kPutdownSoundGeneric = 0xA0, + kPickupSoundWeapon = 0xA1, + kPutdownSoundWeapon = 0xA2, + kPickupSoundArmor = 0xA3, + kPutdownSoundArmor = 0xA4, + kPickupSoundBook = 0xA5, + kPutdownSoundBook = 0xA6, + kPickupSoundIngredient = 0xA7, + kPutdownSoundIngredient = 0xA8, + kHarvestSound = 0xA9, + kHarvestFailedSound = 0xAA, + kWardBreakSound = 0xAB, + kWardAbsorbSound = 0xAC, + kWardDeflectSound = 0xAD, + kMagicFailSound = 0xAE, + kShoutFailSound = 0xAF, + kHeartbeatSoundFast = 0xB0, + kHeartbeatSoundSlow = 0xB1, + kImagespaceLowHealth = 0xB2, + kSoulCapturedSound = 0xB3, + kNoActivationSound = 0xB4, + kMapMenuLoopingSound = 0xB5, + kDialogueVoiceCategory = 0xB6, + kNonDialogueVoiceCategory = 0xB7, + kSFXToFadeInDialogueCategory = 0xB8, + kPauseDuringMenuCategoryFade = 0xB9, + kPauseDuringMenuCategoryImmediate = 0xBA, + kPauseDuringLoadingMenuCategory = 0xBB, + kMusicSoundCategory = 0xBC, + kStatsMuteCategory = 0xBD, + kStatsMusic = 0xBE, + kMasterSoundCategory = 0xBF, + kDialogueOutputModel3D = 0xC0, + kDialogueOutputModel2D = 0xC1, + kPlayersOutputModel1stPerson = 0xC2, + kPlayersOutputModel3rdPerson = 0xC3, + kInterfaceOutputModel = 0xC4, + kReverbType = 0xC5, + kUnderwaterLoopSound = 0xC6, + kUnderwaterReverbType = 0xC7, + kKeywordHorse = 0xC8, + kKeywordUndead = 0xC9, + kKeywordNPC = 0xCA, - kKeywordDummyObject = 204, - kKeywordUseGeometryEmitter, - kKeywordMustStop, - kMaleFaceTextureSetHead, - kMaleFaceTextureSetMouth, - kMaleFaceTextureSetEyes, - kFemaleFaceTextureSetHead, - kFemaleFaceTextureSetMouth, - kFemaleFaceTextureSetEyes, - kImageSpaceModifierForInventoryMenu, - kImageSpaceModifierForPipboyMenuInPowerArmor, - kPackageTemplate, - kMainMenuCell, - kDefaultMovementTypeDefault, - kDefaultMovementTypeSwim, - kDefaultMovementTypeFly, - kDefaultMovementTypeSneak, - kKeywordSpecialFurniture, - kKeywordFurnitureForces1stPerson, - kKeywordFurnitureForces3rdPerson, - kKeywordActivatorFurnitureNoPlayer, - kTelekinesisGrabSound, - kTelekinesisThrowSound, - kWorldMapWeather, - kHelpManualPC, - kHelpManualXBox, - kKeywordTypeAmmo, - kKeywordTypeArmor, - kKeywordTypeBook, - kKeywordTypeIngredient, - kKeywordTypeKey, - kKeywordTypeMisc, - kKeywordTypeSoulGem, - kKeywordTypeWeapon, - kKeywordTypePotion, - kBaseWeaponEnchantment, - kBaseArmorEnchantment, - kBasePotion, - kBasePoison, - kKeywordDragon, - kKeywordMovable, - kArtObjectAbsorbEffect, - kWeaponMaterialList, - kArmorMaterialList, - kKeywordDisallowEnchanting, - kFavortravelmarkerlocation, - kTeammateReadyWeapon, - kKeywordHoldLocation, - kKeywordCivilWarOwner, - kKeywordCivilWarNeutral, - kLocRefTypeCivilWarSoldier, - kKeywordClearableLocation, - kLocRefTypeResourceDestructible, - kFormListHairColorList, - kComplexSceneObject, - kKeywordReusableSoulGem, - kKeywordAnimal, - kKeywordDaedra, - kKeywordRobot, - kKeywordNirnroot, - kFightersGuildFaction, - kMagesGuildFaction, - kThievesGuildFaction, - kDarkBrotherhoodFaction, - kJarlFaction, - kBunnyFaction, - kPlayerIsVampireVariable, + kKeywordDummyObject = 0xCC, + kKeywordUseGeometryEmitter = 0xCD, + kKeywordMustStop = 0xCE, + kMaleFaceTextureSetHead = 0xCF, + kMaleFaceTextureSetMouth = 0xD0, + kMaleFaceTextureSetEyes = 0xD1, + kFemaleFaceTextureSetHead = 0xD2, + kFemaleFaceTextureSetMouth = 0xD3, + kFemaleFaceTextureSetEyes = 0xD4, + kImageSpaceModifierForInventoryMenu = 0xD5, + kImageSpaceModifierForPipboyMenuInPowerArmor = 0xD6, + kPackageTemplate = 0xD7, + kMainMenuCell = 0xD8, + kDefaultMovementTypeDefault = 0xD9, + kDefaultMovementTypeSwim = 0xDA, + kDefaultMovementTypeFly = 0xDB, + kDefaultMovementTypeSneak = 0xDC, + kKeywordSpecialFurniture = 0xDD, + kKeywordFurnitureForces1stPerson = 0xDE, + kKeywordFurnitureForces3rdPerson = 0xDF, + kKeywordActivatorFurnitureNoPlayer = 0xE0, + kTelekinesisGrabSound = 0xE1, + kTelekinesisThrowSound = 0xE2, + kWorldMapWeather = 0xE3, + kHelpManualPC = 0xE4, + kHelpManualXBox = 0xE5, + kKeywordTypeAmmo = 0xE6, + kKeywordTypeArmor = 0xE7, + kKeywordTypeBook = 0xE8, + kKeywordTypeIngredient = 0xE9, + kKeywordTypeKey = 0xEA, + kKeywordTypeMisc = 0xEB, + kKeywordTypeSoulGem = 0xEC, + kKeywordTypeWeapon = 0xED, + kKeywordTypePotion = 0xEE, + kBaseWeaponEnchantment = 0xEF, + kBaseArmorEnchantment = 0xF0, + kBasePotion = 0xF1, + kBasePoison = 0xF2, + kKeywordDragon = 0xF3, + kKeywordMovable = 0xF4, + kArtObjectAbsorbEffect = 0xF5, + kWeaponMaterialList = 0xF6, + kArmorMaterialList = 0xF7, + kKeywordDisallowEnchanting = 0xF8, + kFavortravelmarkerlocation = 0xF9, + kTeammateReadyWeapon = 0xFA, + kKeywordHoldLocation = 0xFB, + kKeywordCivilWarOwner = 0xFC, + kKeywordCivilWarNeutral = 0xFD, + kLocRefTypeCivilWarSoldier = 0xFE, + kKeywordClearableLocation = 0xFF, + kLocRefTypeResourceDestructible = 0x100, + kFormListHairColorList = 0x101, + kComplexSceneObject = 0x102, + kKeywordReusableSoulGem = 0x103, + kKeywordAnimal = 0x104, + kKeywordDaedra = 0x105, + kKeywordRobot = 0x106, + kKeywordNirnroot = 0x107, + kFightersGuildFaction = 0x108, + kMagesGuildFaction = 0x109, + kThievesGuildFaction = 0x10A, + kDarkBrotherhoodFaction = 0x10B, + kJarlFaction = 0x10C, + kBunnyFaction = 0x10D, + kPlayerIsVampireVariable = 0x10E, - kRoadMarker = 272, - kKeywordScaleActorTo10, - kKeywordVampire, - kKeywordForge, - kKeywordCookingPot, - kKeywordSmelter, - kKeywordTanningRack, - kHelpBasicLockpickingPC, - kHelpBasicLockpickingConsole, - kHelpBasicForging, - kHelpBasicCooking, - kHelpBasicSmelting, - kHelpBasicTanning, - kHelpBasicObjectCreation, - kHelpBasicEnchanting, - kHelpBasicSmithingWeapon, - kHelpBasicSmithingArmor, - kHelpBasicAlchemy, - kHelpBarter, - kHelpLevelingup, - kHelpSkillsMenu, - kHelpMapMenu, - kHelpJournal, - kHelpLowHealth, - kHelpLowMagicka, - kHelpLowStamina, - kHelpJail, - kHelpTeamateFavor, - kHelpWeaponCharge, - kHelpFavorites, - kKinectHelpFormList, - kImagespaceLoadscreen, - kKeywordWeaponMaterialDaedric, - kKeywordWeaponMaterialDraugr, - kKeywordWeaponMaterialDraugrHoned, - kKeywordWeaponMaterialDwarven, - kKeywordWeaponMaterialEbony, - kKeywordWeaponMaterialElven, - kKeywordWeaponMaterialFalmer, - kKeywordWeaponMaterialFalmerHoned, - kKeywordWeaponMaterialGlass, - kKeywordWeaponMaterialImperial, - kKeywordWeaponMaterialIron, - kKeywordWeaponMaterialOrcish, - kKeywordWeaponMaterialSteel, - kKeywordWeaponMaterialWood, - kKeywordWeaponTypeBoundArrow, - kKeywordArmorMaterialDaedric, - kKeywordArmorMaterialDragonplate, - kKeywordArmorMaterialDragonscale, - kKeywordArmorMaterialDragonbone, - kKeywordArmorMaterialDwarven, - kKeywordArmorMaterialEbony, - kKeywordArmorMaterialElven, - kKeywordArmorMaterialElvenSplinted, - kKeywordArmorMaterialFullLeather, - kKeywordArmorMaterialGlass, - kKeywordArmorMaterialHide, - kKeywordArmorMaterialImperial, - kKeywordArmorMaterialImperialHeavy, - kKeywordArmorMaterialImperialReinforced, - kKeywordArmorMaterialIron, - kKeywordArmorMaterialIronBanded, - kKeywordArmorMaterialOrcish, - kKeywordArmorMaterialScaled, - kKeywordArmorMaterialSteel, - kKeywordArmorMaterialSteelPlate, - kKeywordArmorMaterialStormcloak, - kKeywordArmorMaterialStudded, - kKeywordGenericCraftableKeyword01, - kKeywordGenericCraftableKeyword02, - kKeywordGenericCraftableKeyword03, - kKeywordGenericCraftableKeyword04, - kKeywordGenericCraftableKeyword05, - kKeywordGenericCraftableKeyword06, - kKeywordGenericCraftableKeyword07, - kKeywordGenericCraftableKeyword08, - kKeywordGenericCraftableKeyword09, - kKeywordGenericCraftableKeyword10, - kKeywordnullptrMOD, - kKeywordJewelry, - kKeywordCuirass, - kLocalMapHidePlane, - kSnowLODMaterial, - kSnowLODMaterialHD, - kDialogueImagespace, - kDialogueFollowerQuest, - kPotentialFollowerFaction, + kRoadMarker = 0x110, + kKeywordScaleActorTo10 = 0x111, + kKeywordVampire = 0x112, + kKeywordForge = 0x113, + kKeywordCookingPot = 0x114, + kKeywordSmelter = 0x115, + kKeywordTanningRack = 0x116, + kHelpBasicLockpickingPC = 0x117, + kHelpBasicLockpickingConsole = 0x118, + kHelpBasicForging = 0x119, + kHelpBasicCooking = 0x11A, + kHelpBasicSmelting = 0x11B, + kHelpBasicTanning = 0x11C, + kHelpBasicObjectCreation = 0x11D, + kHelpBasicEnchanting = 0x11E, + kHelpBasicSmithingWeapon = 0x11F, + kHelpBasicSmithingArmor = 0x120, + kHelpBasicAlchemy = 0x121, + kHelpBarter = 0x122, + kHelpLevelingup = 0x123, + kHelpSkillsMenu = 0x124, + kHelpMapMenu = 0x125, + kHelpJournal = 0x126, + kHelpLowHealth = 0x127, + kHelpLowMagicka = 0x128, + kHelpLowStamina = 0x129, + kHelpJail = 0x12A, + kHelpTeamateFavor = 0x12B, + kHelpWeaponCharge = 0x12C, + kHelpFavorites = 0x12D, + kKinectHelpFormList = 0x12E, + kImagespaceLoadscreen = 0x12F, + kKeywordWeaponMaterialDaedric = 0x130, + kKeywordWeaponMaterialDraugr = 0x131, + kKeywordWeaponMaterialDraugrHoned = 0x132, + kKeywordWeaponMaterialDwarven = 0x133, + kKeywordWeaponMaterialEbony = 0x134, + kKeywordWeaponMaterialElven = 0x135, + kKeywordWeaponMaterialFalmer = 0x136, + kKeywordWeaponMaterialFalmerHoned = 0x137, + kKeywordWeaponMaterialGlass = 0x138, + kKeywordWeaponMaterialImperial = 0x139, + kKeywordWeaponMaterialIron = 0x13A, + kKeywordWeaponMaterialOrcish = 0x13B, + kKeywordWeaponMaterialSteel = 0x13C, + kKeywordWeaponMaterialWood = 0x13D, + kKeywordWeaponTypeBoundArrow = 0x13E, + kKeywordArmorMaterialDaedric = 0x13F, + kKeywordArmorMaterialDragonplate = 0x140, + kKeywordArmorMaterialDragonscale = 0x141, + kKeywordArmorMaterialDragonbone = 0x142, + kKeywordArmorMaterialDwarven = 0x143, + kKeywordArmorMaterialEbony = 0x144, + kKeywordArmorMaterialElven = 0x145, + kKeywordArmorMaterialElvenSplinted = 0x146, + kKeywordArmorMaterialFullLeather = 0x147, + kKeywordArmorMaterialGlass = 0x148, + kKeywordArmorMaterialHide = 0x149, + kKeywordArmorMaterialImperial = 0x14A, + kKeywordArmorMaterialImperialHeavy = 0x14B, + kKeywordArmorMaterialImperialReinforced = 0x14C, + kKeywordArmorMaterialIron = 0x14D, + kKeywordArmorMaterialIronBanded = 0x14E, + kKeywordArmorMaterialOrcish = 0x14F, + kKeywordArmorMaterialScaled = 0x150, + kKeywordArmorMaterialSteel = 0x151, + kKeywordArmorMaterialSteelPlate = 0x152, + kKeywordArmorMaterialStormcloak = 0x153, + kKeywordArmorMaterialStudded = 0x154, + kKeywordGenericCraftableKeyword01 = 0x155, + kKeywordGenericCraftableKeyword02 = 0x156, + kKeywordGenericCraftableKeyword03 = 0x157, + kKeywordGenericCraftableKeyword04 = 0x158, + kKeywordGenericCraftableKeyword05 = 0x159, + kKeywordGenericCraftableKeyword06 = 0x15A, + kKeywordGenericCraftableKeyword07 = 0x15B, + kKeywordGenericCraftableKeyword08 = 0x15C, + kKeywordGenericCraftableKeyword09 = 0x15D, + kKeywordGenericCraftableKeyword10 = 0x15E, + kKeywordnullptrMOD = 0x15F, + kKeywordJewelry = 0x160, + kKeywordCuirass = 0x161, + kLocalMapHidePlane = 0x162, + kSnowLODMaterial = 0x163, + kSnowLODMaterialHD = 0x164, + kDialogueImagespace = 0x165, + kDialogueFollowerQuest = 0x166, + kPotentialFollowerFaction = 0x167, - kVampireAvailablePerks = 361, + kVampireAvailablePerks = 0x169, - kVampireRace = 363, - kVampireSpells, - kKeywordMount, - kVerletCape, - kFurnitureTestNPC, - kKeywordConditionalExplosion, - kDefaultLight1, - kDefaultLight2, - kDefaultLight3, - kDefaultLight4, - kPipboyLight, - kActionBeginLoopingActivate, - kActionEndLoopingActivate, - kWorkshopPlayerOwnership, - kQuestMarkerFollower, - kQuestMarkerLocation, - kQuestMarkerEnemy, - kQuestMarkerEnemyAbove, - kQuestMarkerEnemyBelow, - kWorkshopMiscItemKeyword, - kHeavyWeaponItemKeyword, - kMineItemKeyword, - kGrenadeItemKeyword, - kChemItemKeyword, - kAlcoholItemKeyword, - kFoodItemKeyword, - kRepairKitItemKeyword, - kMedbagitemKeyword, - kGlovesitemKeyword, - kHelmetitemkeyword, - kClothesitemkeyword, + kVampireRace = 0x16B, + kVampireSpells = 0x16C, + kKeywordMount = 0x16D, + kVerletCape = 0x16E, + kFurnitureTestNPC = 0x16F, + kKeywordConditionalExplosion = 0x170, + kDefaultLight1 = 0x171, + kDefaultLight2 = 0x172, + kDefaultLight3 = 0x173, + kDefaultLight4 = 0x174, + kPipboyLight = 0x175, + kActionBeginLoopingActivate = 0x176, + kActionEndLoopingActivate = 0x177, + kWorkshopPlayerOwnership = 0x178, + kQuestMarkerFollower = 0x179, + kQuestMarkerLocation = 0x17A, + kQuestMarkerEnemy = 0x17B, + kQuestMarkerEnemyAbove = 0x17C, + kQuestMarkerEnemyBelow = 0x17D, + kWorkshopMiscItemKeyword = 0x17E, + kHeavyWeaponItemKeyword = 0x17F, + kMineItemKeyword = 0x180, + kGrenadeItemKeyword = 0x181, + kChemItemKeyword = 0x182, + kAlcoholItemKeyword = 0x183, + kFoodItemKeyword = 0x184, + kRepairKitItemKeyword = 0x185, + kMedbagitemKeyword = 0x186, + kGlovesitemKeyword = 0x187, + kHelmetitemkeyword = 0x188, + kClothesitemkeyword = 0x189, kTotal }; enum class DEFAULT_OBJECT_TYPE { - kMisc, - kFacegen, - kMovement, - kActions, - kItems, - kSounds, - kKeywords + kMisc = 0x0, + kFacegen = 0x1, + kMovement = 0x2, + kActions = 0x3, + kItems = 0x4, + kSounds = 0x5, + kKeywords = 0x6 }; struct DEFAULT_OBJECT_DATA @@ -500,9 +500,9 @@ namespace RE } // members - TESForm* form; // 20 - REX::EnumSet type; // 28 - BSFixedString formEditorID; // 30 + TESForm* form; // 20 + ENUM_FORM_ID type; // 28 + BSFixedString formEditorID; // 30 private: BGSDefaultObject* ctor(const char* a_name, ENUM_FORM_ID a_formType, const char* a_description) diff --git a/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h b/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h index f226f88b..184a5cd5 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h +++ b/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h @@ -30,16 +30,16 @@ namespace RE enum class HeadPartType { - kMisc, - kFace, - kEyes, - kHair, - kFacialHair, - kScar, - kEyebrows, - kMeatcaps, - kTeeth, - kHeadRear + kMisc = 0x0, + kFace = 0x1, + kEyes = 0x2, + kHair = 0x3, + kFacialHair = 0x4, + kScar = 0x5, + kEyebrows = 0x6, + kMeatcaps = 0x7, + kTeeth = 0x8, + kHeadRear = 0x9 }; [[nodiscard]] bool IsExtraPart() const noexcept { return flags.all(Flag::kExtraPart); } diff --git a/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h b/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h index df741814..107d5690 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h +++ b/CommonLibF4/include/RE/Bethesda/BGSInventoryInterface.h @@ -73,6 +73,13 @@ namespace RE return func(this, a_handleID); } + [[nodiscard]] bool ForceMergeStacks(const std::uint32_t& a_handleID) + { + using func_t = decltype(&BGSInventoryInterface::ForceMergeStacks); + static REL::Relocation func{ REL::ID(2194032) }; + return func(this, a_handleID); + } + // members BSTArray agentArray; // B8 }; diff --git a/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h b/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h index fe07372a..5f613dea 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h +++ b/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h @@ -80,6 +80,25 @@ namespace RE }; static_assert(sizeof(CheckStackIDFunctor) == 0x10); + class alignas(0x08) CheckExtraDataFunctor : + public StackDataCompareFunctor // 00 + { + public: + static constexpr auto RTTI{ RTTI::BGSInventoryItem__CheckExtraDataFunctor }; + static constexpr auto VTABLE{ VTABLE::BGSInventoryItem__CheckExtraDataFunctor }; + + CheckExtraDataFunctor(const BGSInventoryItem::Stack* a_stack) noexcept : + extra(a_stack->extra.get()) + {} + + // override (StackDataCompareFunctor) + bool CompareData(const BGSInventoryItem::Stack&) override { return this->extra == extra; } + + // members + const ExtraDataList* extra; // 08 + }; + static_assert(sizeof(CheckExtraDataFunctor) == 0x10); + class __declspec(novtable) alignas(0x08) StackDataWriteFunctor { public: @@ -127,10 +146,31 @@ namespace RE }; static_assert(sizeof(ModifyModDataFunctor) == 0x30); + class __declspec(novtable) SetHealthFunctor : + public StackDataWriteFunctor // 00 + { + public: + static constexpr auto RTTI{ RTTI::BGSInventoryItem__SetHealthFunctor }; + static constexpr auto VTABLE{ VTABLE::BGSInventoryItem__SetHealthFunctor }; + + SetHealthFunctor(float a_health) : + health(a_health) + { + stl::emplace_vtable(this); + } + + // override (StackDataWriteFunctor) + void WriteDataImpl(TESBoundObject&, BGSInventoryItem::Stack&) override; // 01 + + // members + float health; // 10 + }; + static_assert(sizeof(SetHealthFunctor) == 0x18); + bool FindAndWriteStackData(StackDataCompareFunctor& a_compareFunc, StackDataWriteFunctor& a_writeFunc, bool a_manualMerge, ObjectRefHandle a_owner) { using func_t = decltype(&BGSInventoryItem::FindAndWriteStackData); - static REL::Relocation func{ REL::ID(770140) }; + static REL::Relocation func{ REL::ID(2194123) }; return func(this, a_compareFunc, a_writeFunc, a_manualMerge, a_owner); } @@ -145,14 +185,21 @@ namespace RE return iter; } - [[nodiscard]] const char* GetDisplayFullName(std::uint32_t a_stackID) + [[nodiscard]] const char* GetDisplayFullName(std::uint32_t a_stackID) const { - using func_t = decltype(&BGSInventoryItem::GetDisplayFullName); + using func_t = const char* (BGSInventoryItem::*)(std::uint32_t) const; static REL::Relocation func{ REL::ID(2194079) }; return func(this, a_stackID); } - [[nodiscard]] TBO_InstanceData* GetInstanceData(std::uint32_t a_stackID) + [[nodiscard]] const char* GetDisplayFullName(const ExtraDataList* a_extra) const + { + using func_t = const char* (BGSInventoryItem::*)(const ExtraDataList*) const; + static REL::Relocation func{ REL::ID(2194080) }; + return func(this, a_extra); + } + + [[nodiscard]] TBO_InstanceData* GetInstanceData(std::uint32_t a_stackID) const { using func_t = decltype(&BGSInventoryItem::GetInstanceData); static REL::Relocation func{ REL::ID(2194072) }; @@ -166,6 +213,20 @@ namespace RE return func(this, a_stackID, a_scale); } + ExtraDataList GetExtraDataAt(std::uint32_t a_index) + { + using func_t = decltype(&BGSInventoryItem::GetExtraDataAt); + static REL::Relocation func{ REL::ID(2194092) }; + return func(this, a_index); + } + + [[nodiscard]] void MergeStacks() + { + using func_t = decltype(&BGSInventoryItem::MergeStacks); + static REL::Relocation func{ REL::ID(2194109) }; + return func(this); + } + // members TESBoundObject* object; // 00 BSTSmartPointer stackData; // 08 diff --git a/CommonLibF4/include/RE/Bethesda/BGSMod.h b/CommonLibF4/include/RE/Bethesda/BGSMod.h index e3dc3270..8115d8e4 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSMod.h +++ b/CommonLibF4/include/RE/Bethesda/BGSMod.h @@ -180,7 +180,7 @@ namespace RE::BGSMod TESObjectMISC* GetLooseMod() { using func_t = decltype(&Mod::GetLooseMod); - static REL::Relocation func{ REL::ID(1359613) }; + static REL::Relocation func{ REL::ID(2197514) }; return func(this); } diff --git a/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h b/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h index 2e2c34ef..442fa362 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h +++ b/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h @@ -17,12 +17,12 @@ namespace RE enum class PRIMITIVE_TYPE { - kNone, - kBox, - kSphere, - kPlane, - kLine, - kEllipsoid + kNone = 0x0, + kBox = 0x1, + kSphere = 0x2, + kPlane = 0x3, + kLine = 0x4, + kEllipsoid = 0x5 }; virtual ~BGSPrimitive(); // 00 diff --git a/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h b/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h index a15ef053..30328b6a 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h +++ b/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h @@ -34,23 +34,23 @@ namespace RE enum SCENE_ACTION_PLAYER_RESPONSE_TYPE : std::uint32_t { - kPositive = 0, - kNegative = 1, - kNeutral = 2, - kQuestion = 3, - kTotal = 4, - kNone + kPositive = 0x0, + kNegative = 0x1, + kNeutral = 0x2, + kQuestion = 0x3, + kTotal = 0x4, + kNone = 0x5 }; enum SCENE_ACTION_TYPE : std::uint32_t { - kDialogue = 0, - kPackage = 1, - kTimer = 2, - kPlayerDialogue = 3, - kStartScene = 4, - kNPCResponse = 5, - kRadio = 6, + kDialogue = 0x0, + kPackage = 0x1, + kTimer = 0x2, + kPlayerDialogue = 0x3, + kStartScene = 0x4, + kNPCResponse = 0x5, + kRadio = 0x6, }; enum class Flag @@ -68,34 +68,34 @@ namespace RE enum class Status { - kStopped, - kRunning, - kComplete + kStopped = 0x0, + kRunning = 0x1, + kComplete = 0x2 }; virtual ~BGSSceneAction(); // 00 // add - virtual void Unk_01(void); // 01 - virtual void Unk_02(void); // 02 - virtual void Unk_03(void); // 03 - virtual void Unk_04(void); // 04 - virtual void Unk_05(void); // 05 + virtual void Load(void); // 01 + virtual void InitItem(void); // 02 + virtual void OnDelete(void); // 03 + virtual void ClearData(void); // 04 + virtual void Copy(void); // 05 virtual bool QIsLooping(void); // 06 virtual bool QFaceHeadTrackTarget(const BGSScene* scene); // 07 virtual SCENE_ACTION_TYPE GetActionType() const = 0; // 08 virtual bool QActionCanEnd(); // 09 virtual bool IsPackageActive(BGSScene* scene, TESPackage* package, Actor* actor); // 0A - virtual void Unk_0B(void); // 0B - virtual void Unk_0C(void); // 0C - virtual void Unk_0D(void); // 0D - virtual void Unk_0E(void); // 0E - virtual void Unk_0F(void); // 0F - virtual void Unk_10(void); // 10 - virtual void Unk_11(void); // 11 + virtual void LoadGame(void); // 0B + virtual void SaveGame(void); // 0C + virtual void Revert(void); // 0D + virtual void InitLoadGame(void); // 0E + virtual void ResetActionData(void); // 0F + virtual void SetInput(void); // 10 + virtual float GetActionPercentDone(const BGSScene* scene); // 11 virtual void StartAction(BGSScene* scene); // 12 virtual void EndAction(BGSScene* scene); // 13 - virtual void CleanUpActionActor(void); // 14 + virtual void CleanUpActionActor(BGSScene* scene); // 14 virtual void UpdateAction(BGSScene* scene); // 14 // members @@ -154,16 +154,36 @@ namespace RE static constexpr auto RTTI{ RTTI::BGSSceneActionPlayerDialogue }; static constexpr auto VTABlE{ VTABLE::BGSSceneActionPlayerDialogue }; - std::uint64_t dialogueTarget; // 90 - TESTopic* pNPCResponseTopics[4]; // 98 - BGSKeyword* pNPCResponseSubtypeKeywords[4]; // B8 - TESTopic* pTopic; // D8 - SCENE_ACTION_PLAYER_RESPONSE_TYPE playerInput; // E0 + std::uint64_t dialogueTarget; // 90 + TESTopic* pNPCResponseTopics[4]; // 98 + BGSKeyword* pNPCResponseSubtypeKeywords[4]; // B8 + TESTopic* pTopic; // D8 + std::uint32_t playerInput; // E0 + + TESTopicInfo* GetCurrentTopicInfo(BGSScene* a_parentScene, TESObjectREFR* a_target, std::uint32_t a_type) + { + using func_t = decltype(&BGSSceneActionPlayerDialogue::GetCurrentTopicInfo); + static REL::Relocation func{ REL::ID(2196825) }; + return func(this, a_parentScene, a_target, a_type); + } }; static_assert(sizeof(BGSSceneActionPlayerDialogue) == 0xE8); - class __declspec(novtable) BGSSceneActionNPCResponseDialogue : public BGSSceneActionConversationBase - {}; + class __declspec(novtable) BGSSceneActionNPCResponseDialogue : + public BGSSceneActionConversationBase + { + public: + static constexpr auto RTTI{ RTTI::BGSSceneActionNPCResponseDialogue }; + static constexpr auto VTABLE{ VTABLE::BGSSceneActionNPCResponseDialogue }; + + TESTopicInfo* GetCurrentTopicInfo(BGSScene* a_parentScene) + { + using func_t = decltype(&BGSSceneActionNPCResponseDialogue::GetCurrentTopicInfo); + static REL::Relocation func{ REL::ID(2196825) }; + return func(this, a_parentScene); + } + }; + static_assert(sizeof(BGSSceneActionNPCResponseDialogue) == 0x90); class __declspec(novtable) BGSSceneActionStartScene : public BGSSceneAction diff --git a/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h b/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h index 5b90323f..4f4af1bb 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h +++ b/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h @@ -30,11 +30,11 @@ namespace RE public: enum class LightingShaderEnum { - kStandard, - kWater, - kEffect, - kSky, - kTallGrass + kStandard = 0x0, + kWater = 0x1, + kEffect = 0x2, + kSky = 0x3, + kTallGrass = 0x4 }; // members diff --git a/CommonLibF4/include/RE/Bethesda/BSContainer.h b/CommonLibF4/include/RE/Bethesda/BSContainer.h index 0a5c3340..868c6924 100644 --- a/CommonLibF4/include/RE/Bethesda/BSContainer.h +++ b/CommonLibF4/include/RE/Bethesda/BSContainer.h @@ -4,7 +4,7 @@ namespace RE::BSContainer { enum class ForEachResult { - kContinue = 0, - kStop = 1 + kContinue = 0x0, + kStop = 0x1 }; } diff --git a/CommonLibF4/include/RE/Bethesda/BSExtraData.h b/CommonLibF4/include/RE/Bethesda/BSExtraData.h index 3931b1f1..f296e8c6 100644 --- a/CommonLibF4/include/RE/Bethesda/BSExtraData.h +++ b/CommonLibF4/include/RE/Bethesda/BSExtraData.h @@ -380,7 +380,106 @@ namespace RE struct __declspec(novtable) MapMarkerData : public TESFullName // 00 { - std::uint32_t flags; // 10 + enum MARKER_TYPE : std::uint16_t + { + kCave = 0x0, + kCity = 0x1, + kDiamondCity = 0x2, + kEncampment = 0x3, + kIndustrial = 0x4, + kGovtBuilding = 0x5, + kMetro = 0x6, + kMilitaryBase = 0x7, + kLandmark = 0x8, + kOffice = 0x9, + kRuinsTown = 0xA, + kRuinsUrban = 0xB, + kSanctuary = 0xC, + kSettlement = 0xD, + kSewer = 0xE, + kVault = 0xF, + kAirfield = 0x10, + kBunkerHill = 0x11, + kCamper = 0x12, + kCar = 0x13, + kChurch = 0x14, + kCountryClub = 0x15, + kCustomHouse = 0x16, + kDriveIn = 0x17, + kElevatedHighway = 0x18, + kFaneuilHall = 0x19, + kFarm = 0x1A, + kFillingStation = 0x1B, + kForest = 0x1C, + kGoodNeighbor = 0x1D, + kGraveyard = 0x1E, + kHospital = 0x1F, + kIndustrialDome = 0x20, + kIndustrialStacks = 0x21, + kInstitute = 0x22, + kIrishPride = 0x23, + kJunkyard = 0x24, + kObservatory = 0x25, + kPier = 0x26, + kPondOrLake = 0x27, + kQuarry = 0x28, + kRadioactiveArea = 0x29, + kRadioTower = 0x2A, + kSalem = 0x2B, + kSchool = 0x2C, + kShipwreck = 0x2D, + kSubmarine = 0x2E, + kSwanPond = 0x2F, + kSynthHead = 0x0, + kTown = 0x31, + kBOS = 0x32, + kBrownstone = 0x33, + kBunker = 0x34, + kCastle = 0x35, + kSkyscraper = 0x36, + kLibertalia = 0x37, + kLowrise = 0x38, + kMinutemen = 0x39, + kPoliceStation = 0x3A, + kPrydwen = 0x3B, + kRailroadFaction = 0x3C, + kRailroad = 0x3D, + kSatellite = 0x3E, + kSentinel = 0x3F, + kUSSConstitution = 0x40, + kMechanist = 0x41, + kRaiderSettlement = 0x42, + kVassalSettlement = 0x43, + kPotentialVassalSettlement = 0x44, + kBottlingPlant = 0x45, + kGalactic = 0x46, + kHub = 0x47, + kKiddieKingdom = 0x48, + kMonorail = 0x49, + kRides = 0x4A, + kSafari = 0x4B, + kWildWest = 0x4C, + kPOI = 0x4D, + kDisciples = 0x4E, + kOperators = 0x4F, + kPack = 0x50, + kDoor = 0x51, + kCountEditor = 0x52, + kQuest = 0x53, + kQuestDoor = 0x54, + kQuestMultiple = 0x55, + kPlayerSet = 0x56, + kPlayerLocation = 0x57, + kPowerArmorLocation = 0x58, + kDogmeat = 0x59, + kTeammate = 0x5A, + + kCountTotal = 0x5B + }; + + std::uint8_t flags; // 10 + std::uint8_t originalFlags; // 11 + MARKER_TYPE type; // 12 }; static_assert(sizeof(MapMarkerData) == 0x18); @@ -858,6 +957,23 @@ namespace RE !std::is_reference_v; } + namespace ComparisonQualifiers + { + static bool ContainerQualifier(const BSExtraData* a_extraData) + { + using func_t = decltype(ComparisonQualifiers::ContainerQualifier); + REL::Relocation func{ REL::ID(2190674) }; + return func(a_extraData); + } + + static bool UIQualifier(const BSExtraData* a_extraData) + { + using func_t = decltype(ComparisonQualifiers::UIQualifier); + REL::Relocation func{ REL::ID(2190675) }; + return func(a_extraData); + } + }; + class ExtraDataList : public BSIntrusiveRefCounted // 00 { @@ -976,6 +1092,28 @@ namespace RE return func(this); } + bool IsDamaged() + { + using func_t = decltype(&ExtraDataList::IsDamaged); + static REL::Relocation func{ REL::ID(2190224) }; + return func(this); + } + + typedef bool (*ComparisonQualifier)(const BSExtraData*); + bool CompareList(const ExtraDataList* a_compare, ComparisonQualifier a_qualifier) + { + using func_t = decltype(&ExtraDataList::CompareList); + REL::Relocation func{ REL::ID(2190098) }; + return func(this, a_compare, a_qualifier); + } + + void SetFavorite(char a_quickkeyIndex) + { + using func_t = decltype(&ExtraDataList::SetFavorite); + static REL::Relocation func{ REL::ID(2190188) }; + return func(this, a_quickkeyIndex); + } + // members BaseExtraList extraData; // 08 mutable BSReadWriteLock extraRWLock; // 20 diff --git a/CommonLibF4/include/RE/Bethesda/BSGraphics.h b/CommonLibF4/include/RE/Bethesda/BSGraphics.h index 2f758d6c..82c01f77 100644 --- a/CommonLibF4/include/RE/Bethesda/BSGraphics.h +++ b/CommonLibF4/include/RE/Bethesda/BSGraphics.h @@ -362,7 +362,7 @@ namespace RE VA_LANDDATA = 0x7, VA_EYEDATA = 0x8, - VA_COUNT = 9 + VA_COUNT = 0X9 }; enum Flags : std::uint16_t diff --git a/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h b/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h index 24ec12ad..348edec4 100644 --- a/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h +++ b/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h @@ -44,13 +44,13 @@ namespace RE public: enum class BS_DEVICES { - kKeyboard, - kMouse, - kGamepad, - kDebugGamepad, - kVirtualKeyboard, + kKeyboard = 0x0, + kMouse = 0x1, + kGamepad = 0x2, + kDebugGamepad = 0x3, + kVirtualKeyboard = 0x4, - kTotal + kTotal = 0x5 }; [[nodiscard]] static BSInputDeviceManager* GetSingleton() diff --git a/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h b/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h index 35bc6fc2..d17395fb 100644 --- a/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h +++ b/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h @@ -43,7 +43,7 @@ namespace RE [[nodiscard]] std::uint32_t DecRef() const { using func_t = decltype(&BSInputEnableLayer::DecRef); - static REL::Relocation func{ REL::ID(659989) }; + static REL::Relocation func{ REL::ID(2268272) }; return func(this); } diff --git a/CommonLibF4/include/RE/Bethesda/BSMTAManager.h b/CommonLibF4/include/RE/Bethesda/BSMTAManager.h index c5a35e14..59702545 100644 --- a/CommonLibF4/include/RE/Bethesda/BSMTAManager.h +++ b/CommonLibF4/include/RE/Bethesda/BSMTAManager.h @@ -51,7 +51,7 @@ namespace RE kWaterStencil = 0x15, kWaterDepth = 0x16, - kTotal + kTotal = 0x17 }; struct CommandBufferPassesMapAccess; @@ -127,9 +127,9 @@ namespace RE { enum class MODE { - kIdle, - kCollecting, - kExecuting, + kIdle = 0x0, + kCollecting = 0x1, + kExecuting = 0x2, }; class CalculateBoneMatricesTask diff --git a/CommonLibF4/include/RE/Bethesda/BSModelDB.h b/CommonLibF4/include/RE/Bethesda/BSModelDB.h index 8942a42a..4539673d 100644 --- a/CommonLibF4/include/RE/Bethesda/BSModelDB.h +++ b/CommonLibF4/include/RE/Bethesda/BSModelDB.h @@ -18,7 +18,7 @@ namespace RE kActorBodyPart = 0x7, kRenderedMenu = 0x8, kInvisible = 0x9, - kSkyCell = 0xa, + kSkyCell = 0xA, }; struct BSModelDB diff --git a/CommonLibF4/include/RE/Bethesda/BSRandom.h b/CommonLibF4/include/RE/Bethesda/BSRandom.h index 14f34e32..e50ece36 100644 --- a/CommonLibF4/include/RE/Bethesda/BSRandom.h +++ b/CommonLibF4/include/RE/Bethesda/BSRandom.h @@ -10,5 +10,19 @@ namespace RE static REL::Relocation func{ REL::ID(2267950) }; return func(a_min, a_max); } + + inline float Float(float a_min, float a_max) + { + using func_t = decltype(&BSRandom::Float); + static REL::Relocation func{ REL::ID(2267953) }; + return func(a_min, a_max); + } + + inline float Float0To1() + { + using func_t = decltype(&BSRandom::Float0To1); + static REL::Relocation func{ REL::ID(2267954) }; + return func(); + } } } diff --git a/CommonLibF4/include/RE/Bethesda/BSResource/BSResourceEnums.h b/CommonLibF4/include/RE/Bethesda/BSResource/BSResourceEnums.h index b0a16cc0..2fae072f 100644 --- a/CommonLibF4/include/RE/Bethesda/BSResource/BSResourceEnums.h +++ b/CommonLibF4/include/RE/Bethesda/BSResource/BSResourceEnums.h @@ -4,22 +4,22 @@ namespace RE::BSResource { enum class ErrorCode : std::uint32_t { - kNone = 0, - kNotExist = 1, - kInvalidPath = 2, - kFileError = 3, - kInvalidType = 4, - kMemoryError = 5, - kBusy = 6, - kInvalidParam = 7, - kUnsupported = 8 + kNone = 0x0, + kNotExist = 0x1, + kInvalidPath = 0x2, + kFileError = 0x3, + kInvalidType = 0x4, + kMemoryError = 0x5, + kBusy = 0x6, + kInvalidParam = 0x7, + kUnsupported = 0x8 }; enum class SeekMode { - kSet = 0, - kCurrent = 1, - kEnd = 2 + kSet = 0x0, + kCurrent = 0x1, + kEnd = 0x2 }; struct FileID diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/ErrorLogger.h b/CommonLibF4/include/RE/Bethesda/BSScript/ErrorLogger.h index 2b588138..5dd38d0d 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/ErrorLogger.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/ErrorLogger.h @@ -29,10 +29,10 @@ namespace RE enum class Severity { - kInfo, - kWarning, - kError, - kFatal + kInfo = 0x0, + kWarning = 0x1, + kError = 0x2, + kFatal = 0x3 }; struct PerThreadErrorCounts diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/IFunction.h b/CommonLibF4/include/RE/Bethesda/BSScript/IFunction.h index f683a04f..566ec062 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/IFunction.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/IFunction.h @@ -38,18 +38,18 @@ namespace RE enum class CallResult { - kCompleted, - kSetupForVM, - kInProgress, - kFailedRetry, - kFailedAbort + kCompleted = 0x0, + kSetupForVM = 0x1, + kInProgress = 0x2, + kFailedRetry = 0x3, + kFailedAbort = 0x4 }; enum class FunctionType { - kNormal, - kPropertyGetter, - kPropertySetter + kNormal = 0x0, + kPropertyGetter = 0x1, + kPropertySetter = 0x2 }; virtual ~IFunction() = default; // 00 diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/ObjectTypeInfo.h b/CommonLibF4/include/RE/Bethesda/BSScript/ObjectTypeInfo.h index d8c9f94e..f7c402b7 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/ObjectTypeInfo.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/ObjectTypeInfo.h @@ -32,10 +32,10 @@ namespace RE enum class LinkValidState : std::uint32_t { - kNotLinked, - kCurrentlyLinking, - kLinkedInvalid, - kLinkedValid + kNotLinked = 0x0, + kCurrentlyLinking = 0x1, + kLinkedInvalid = 0x2, + kLinkedValid = 0x3 }; [[nodiscard]] std::uint32_t GetVariableCount() const noexcept @@ -123,7 +123,7 @@ namespace RE enum : std::uint32_t { kFuncCountMask = 0x1FF, - kFuncOffsetShift = 9 + kFuncOffsetShift = 0x9 }; struct Func diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h b/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h index 57313bee..8235a66b 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h @@ -48,22 +48,22 @@ namespace RE enum class FreezeState { - kUnfrozen, - kFreezing, - kFrozen + kUnfrozen = 0x0, + kFreezing = 0x1, + kFrozen = 0x2 }; enum class State { - kRunning, - kFinished, - kWaitingOnMemory, - kWaitingOnLatentFunction, - kWaitingInOtherStackForCall, - kWaitingInOtherStackForReturn, - kWaitingInOtherStackForReturnNoPop, - kRetryReturnNoPop, - kRetryCall + kRunning = 0x0, + kFinished = 0x1, + kWaitingOnMemory = 0x2, + kWaitingOnLatentFunction = 0x3, + kWaitingInOtherStackForCall = 0x4, + kWaitingInOtherStackForReturn = 0x5, + kWaitingInOtherStackForReturnNoPop = 0x6, + kRetryReturnNoPop = 0x7, + kRetryCall = 0x8 }; struct MemoryPageData diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h b/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h index f139a438..acee64f3 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h @@ -33,10 +33,10 @@ namespace RE enum class LinkValidState { - kNotLinked, - kCurrentlyLinking, - kLinkedInvalid, - kLinkedValid + kNotLinked = 0x0, + kCurrentlyLinking = 0x1, + kLinkedInvalid = 0x2, + kLinkedValid = 0x3 }; struct StructVar diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h b/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h index 7105d278..618b95f2 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h @@ -24,24 +24,24 @@ namespace RE public: enum class RawType : std::uint32_t { - kNone, - kObject, - kString, - kInt, - kFloat, - kBool, - kVar, - kStruct, - - kArrayStart = 10, - kArrayObject, - kArrayString, - kArrayInt, - kArrayFloat, - kArrayBool, - kArrayVar, - kArrayStruct, - kArrayEnd + kNone = 0x0, + kObject = 0x1, + kString = 0x2, + kInt = 0x3, + kFloat = 0x4, + kBool = 0x5, + kVar = 0x6, + kStruct = 0x7, + + kArrayStart = 0xA, + kArrayObject = 0xB, + kArrayString = 0xC, + kArrayInt = 0xD, + kArrayFloat = 0xE, + kArrayBool = 0xF, + kArrayVar = 0x10, + kArrayStruct = 0x11, + kArrayEnd = 0x12 }; TypeInfo() noexcept = default; diff --git a/CommonLibF4/include/RE/Bethesda/BSShaderMaterial.h b/CommonLibF4/include/RE/Bethesda/BSShaderMaterial.h index 262b58ea..27f38856 100644 --- a/CommonLibF4/include/RE/Bethesda/BSShaderMaterial.h +++ b/CommonLibF4/include/RE/Bethesda/BSShaderMaterial.h @@ -24,35 +24,35 @@ namespace RE enum class Feature { kNone = static_cast>(-1), - kDefault = 0, - kEnvmap, - kGlowmap, - kParallax, - kFace, - kSkinTint, - kHairTint, - kParallaxOcc, - kLandscape, - kLODLandscape, - kSnow, - kMultiLayerParallax, - kTreeAnim, - kLODObjects, - kMultiIndexSnow, - kLODObjectsHD, - kEye, - kCloud, - kLODLandscapeNoise, - kLODLandscapeBlend, - kDismemberment + kDefault = 0x0, + kEnvmap = 0x1, + kGlowmap = 0x2, + kParallax = 0x3, + kFace = 0x4, + kSkinTint = 0x5, + kHairTint = 0x6, + kParallaxOcc = 0x7, + kLandscape = 0x8, + kLODLandscape = 0x9, + kSnow = 0xA, + kMultiLayerParallax = 0xB, + kTreeAnim = 0xC, + kLODObjects = 0xD, + kMultiIndexSnow = 0xE, + kLODObjectsHD = 0xF, + kEye = 0x10, + kCloud = 0x11, + kLODLandscapeNoise = 0x12, + kLODLandscapeBlend = 0x13, + kDismemberment = 0x14 }; enum class Type { - kBase = 0, - kEffect = 1, - kLighting = 2, - kWater = 3 + kBase = 0x0, + kEffect = 0x1, + kLighting = 0x2, + kWater = 0x3 }; virtual ~BSShaderMaterial(); diff --git a/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h b/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h index ec2c0733..63894300 100644 --- a/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h +++ b/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h @@ -26,17 +26,17 @@ namespace RE enum class TextureTypeEnum { - kBase = 0, - kNormal, - kGlow, - kHeight, - kEnv, - kWrinkles, - kMultilayer, - kBacklightMask, + kBase = 0x0, + kNormal = 0x1, + kGlow = 0x2, + kHeight = 0x3, + kEnv = 0x4, + kWrinkles = 0x5, + kMultilayer = 0x6, + kBacklightMask = 0x7, kSmoothSpec = kBacklightMask, - kTotal, + kTotal }; enum class EShaderPropertyFlag : std::uint64_t diff --git a/CommonLibF4/include/RE/Bethesda/BSTempEffect.h b/CommonLibF4/include/RE/Bethesda/BSTempEffect.h index 4c486434..e9fc5e97 100644 --- a/CommonLibF4/include/RE/Bethesda/BSTempEffect.h +++ b/CommonLibF4/include/RE/Bethesda/BSTempEffect.h @@ -58,18 +58,18 @@ namespace RE enum class TEMP_EFFECT_TYPE { - kTerrain = 0, - kWeaponBlood = 1, - kDecal = 2, - kGeometryDecal = 3, - kParticle = 4, - kDebris = 5, - kSPG = 6, - kDefault = 7, - kRefDefault = 8, - kRefModel = 9, - kRefShader = 10, - kMagicSummon = 11 + kTerrain = 0x0, + kWeaponBlood = 0x1, + kDecal = 0x2, + kGeometryDecal = 0x3, + kParticle = 0x4, + kDebris = 0x5, + kSPG = 0x6, + kDefault = 0x7, + kRefDefault = 0x8, + kRefModel = 0x9, + kRefShader = 0xA, + kMagicSummon = 0xB }; class __declspec(novtable) BSTempEffect : diff --git a/CommonLibF4/include/RE/Bethesda/BSUtilities.h b/CommonLibF4/include/RE/Bethesda/BSUtilities.h index 9c4781e2..1e6010dd 100644 --- a/CommonLibF4/include/RE/Bethesda/BSUtilities.h +++ b/CommonLibF4/include/RE/Bethesda/BSUtilities.h @@ -26,7 +26,7 @@ namespace RE::BSUtilities inline NiAVObject* GetObjectByName(NiAVObject* a_root, const BSFixedString& a_name, bool a_tryInternal, bool a_dontAttach) { using func_t = decltype(&GetObjectByName); - static REL::Relocation func{ REL::ID(843650) }; + static REL::Relocation func{ REL::ID(2274841) }; return func(a_root, a_name, a_tryInternal, a_dontAttach); } } diff --git a/CommonLibF4/include/RE/Bethesda/BSVisit.h b/CommonLibF4/include/RE/Bethesda/BSVisit.h index 65576116..c7ca6dea 100644 --- a/CommonLibF4/include/RE/Bethesda/BSVisit.h +++ b/CommonLibF4/include/RE/Bethesda/BSVisit.h @@ -10,8 +10,8 @@ namespace RE { enum class BSVisitControl { - kContinue = 0, - kStop = 1 + kContinue = 0x0, + kStop = 0x1 }; BSVisitControl TraverseScenegraphGeometries(NiAVObject* a_object, std::function a_func); diff --git a/CommonLibF4/include/RE/Bethesda/Calendar.h b/CommonLibF4/include/RE/Bethesda/Calendar.h index 02ba5a9f..e482b08a 100644 --- a/CommonLibF4/include/RE/Bethesda/Calendar.h +++ b/CommonLibF4/include/RE/Bethesda/Calendar.h @@ -14,19 +14,19 @@ namespace RE { enum Month { - kJanuary, - kFebruary, - kMarch, - kApril, - kMay, - kJune, - kJuly, - kAugust, - kSeptember, - kOctober, - kNovember, - kDecember, - kTotal + kJanuary = 0x0, + kFebruary = 0x1, + kMarch = 0x2, + kApril = 0x3, + kMay = 0x4, + kJune = 0x5, + kJuly = 0x6, + kAugust = 0x7, + kSeptember = 0x8, + kOctober = 0x9, + kNovember = 0xA, + kDecember = 0xB, + kTotal = 0xC }; }; using Month = Months::Month; diff --git a/CommonLibF4/include/RE/Bethesda/ControlMap.h b/CommonLibF4/include/RE/Bethesda/ControlMap.h index 6f63bc8d..3d4630c8 100644 --- a/CommonLibF4/include/RE/Bethesda/ControlMap.h +++ b/CommonLibF4/include/RE/Bethesda/ControlMap.h @@ -10,8 +10,8 @@ namespace RE { enum class PC_GAMEPAD_TYPE { - kDirectX, - kOrbis, + kDirectX = 0x0, + kOrbis = 0x1, kTotal }; diff --git a/CommonLibF4/include/RE/Bethesda/Events.h b/CommonLibF4/include/RE/Bethesda/Events.h index fd3a58e6..ec9f916d 100644 --- a/CommonLibF4/include/RE/Bethesda/Events.h +++ b/CommonLibF4/include/RE/Bethesda/Events.h @@ -1,5 +1,6 @@ #pragma once +#include "RE/Bethesda/Actor.h" #include "RE/Bethesda/BSFixedString.h" #include "RE/Bethesda/BSPointerHandle.h" #include "RE/Bethesda/BSTArray.h" @@ -12,33 +13,35 @@ namespace RE { + class ActiveEffect; class bhkNPCollisionObject; class BGSMessage; class HUDModeType; class TESObjectCELL; class TESObjectREFR; class VATSCommand; + class BGSInstancedQuestObjective; struct InventoryUserUIInterfaceEntry; enum class QuickContainerMode : std::int32_t { - kLoot, - kTeammate, - kPowerArmor, - kTurret, - kWorkshop, - kCrafting, - kStealing, - kStealingPowerArmor + kLoot = 0x0, + kTeammate = 0x1, + kPowerArmor = 0x2, + kTurret = 0x3, + kWorkshop = 0x4, + kCrafting = 0x5, + kStealing = 0x6, + kStealingPowerArmor = 0x7 }; namespace ActorEquipManagerEvent { - enum class Type + enum class Type : std::int32_t { - Equip = 0, - Unequip, + kEquip = 0x0, + kUnequip = 0x1 }; struct Event @@ -52,6 +55,231 @@ namespace RE static_assert(sizeof(Event) == 0x20); } + namespace PerkValueEvents + { + enum class Type : std::int32_t + { + kAdd = 0x0, + kRemove = 0x1 + }; + + struct PerkValueChangedEvent + { + Type changeType; // 00 + BSPointerHandle> owner; // 04 + BGSPerk* perk; // 08 + std::uint8_t rank; // 10 + }; + static_assert(sizeof(PerkValueChangedEvent) == 0x18); + + struct PerkEntryUpdatedEvent + { + BSPointerHandle> owner; // 00 + BGSPerkEntry* perkEntry; // 08 + }; + static_assert(sizeof(PerkEntryUpdatedEvent) == 0x10); + } + + namespace PlayerCharacterQuestEvent + { + enum Type : std::int32_t + { + kAddObjective = 0x0, + kUpdateObjective = 0x1, + kRemoveQuest = 0x2, + kRemoveQuestTarget = 0x3, + kUpdateQuestTarget = 0x4 + }; + + struct Event + { + PlayerCharacterQuestEvent::Type changeType; // 00 + BGSInstancedQuestObjective* questObjective; // 08 + }; + static_assert(sizeof(Event) == 0x10); + } + + struct TESTrackedStatsEvent + { + BSFixedString stat; // 00 + std::int32_t value; // 08 + }; + static_assert(sizeof(TESTrackedStatsEvent) == 0x10); + + namespace TESQuestEvent + { + enum Type : std::int32_t + { + kUpdateQuestActiveStatus = 0x0, + kUpdateQuestEnableStatus = 0x1, + kUpdateQuestStageChange = 0x2, + kUpdateMiscQuestVisibility = 0x3 + }; + + struct Event + { + TESQuestEvent::Type changeType; // 00 + TESQuest* quest; // 08 + }; + static_assert(sizeof(Event) == 0x10); + } + + struct TESLocationClearedEvent + { + const BGSLocation* loc; //00 + }; + static_assert(sizeof(TESLocationClearedEvent) == 0x8); + + namespace PlayerLifeStateChanged + { + struct Event + { + ACTOR_LIFE_STATE lifeState; // 00 + }; + static_assert(sizeof(Event) == 0x4); + } + + namespace PlayerActiveEffectChanged + { + enum Status : std::int32_t + { + kAdded = 0x0, + kRemoved = 0x1, + kStatusChanged = 0x2 + }; + + struct Event + { + BSTSmartPointer effect; // 00 + PlayerActiveEffectChanged::Status status; // 08 + }; + } + + namespace HourPassed + { + // intentional + struct Event + {}; + } + + namespace LevelIncrease + { + struct Event + { + [[nodiscard]] static BSTEventSource* GetEventSource() + { + using func_t = decltype(&Event::GetEventSource); + static REL::Relocation func{ REL::ID(349120) }; // .163 + return func(); + } + + std::uint32_t newLevel; // 00 + }; + static_assert(sizeof(Event) == 0x4); + } + + namespace LoadingStatusChanged + { + struct Event + { + bool isLoading; // 00 + }; + static_assert(sizeof(Event) == 0x1); + } + + namespace ActorItemEquipped + { + struct Event + { + const TESBoundObject* item; // 00 + const Actor* equipper; // 08 + }; + static_assert(sizeof(Event) == 0x10); + } + + namespace PlayerInDialogueChanged + { + struct Event + { + bool isPlayerInDialogue; // 00 + }; + static_assert(sizeof(Event) == 0x1); + } + + namespace LocationMarkerArrayUpdate + { + struct Event + { + bool shouldClearMapMarkers; // 00 + }; + static_assert(sizeof(Event) == 0x1); + } + + namespace LocalMapCameraUpdate + { + // intentional + struct Event + {}; + } + namespace HolotapeStateChanged + { + // intentional + struct Event + {}; + } + + // intentional + struct PlayerUpdateEvent + {}; + + namespace CustomMarkerUpdate + { + // intentional + struct Event + {}; + } + + namespace BGSInventoryItemEvent + { + struct Event + { + BSPointerHandle> owner; // 00 + InventoryInterface::Handle* item; // 04 + }; + } + + namespace FavoriteMgr_Events + { + struct ComponentFavoriteEvent + { + BGSComponent* component; // 00 + bool isFavorited; // 08 + }; + static_assert(sizeof(ComponentFavoriteEvent) == 0x10); + } + + namespace PlayerDifficultySettingChanged + { + struct Event + { + std::uint32_t oldDifficulty; // 00 + std::uint32_t newDifficulty; // 04 + }; + static_assert(sizeof(Event) == 0x8); + } + + namespace TravelMarkerStateChange + { + struct Event + { + BSPointerHandle> markerRef; // 00 + MapMarkerData* data; // 08 + std::uint32_t selectedMarkerIndex; // 10 + bool discovered; // 14 + }; + static_assert(sizeof(Event) == 0x18); + } + struct BGSActorEvent { public: @@ -65,8 +293,8 @@ namespace RE public: enum class CellFlag { - kEnter = 0, - kLeave = 1 + kEnter = 0x0, + kLeave = 0x1 }; // members @@ -89,8 +317,8 @@ namespace RE public: enum class Event { - kOnStartup, - kOnShutdown + kOnStartup = 0x0, + kOnShutdown = 0x1 }; static void InitSDM() @@ -155,16 +383,17 @@ namespace RE return *singleton; } }; + static_assert(sizeof(CanDisplayNextHUDMessage) == 0x2); struct CellAttachDetachEvent { public: - enum class EVENT_TYPE + enum class EVENT_TYPE : std::int32_t { - kPreAttach, - kPostAttach, - kPreDetach, - kPostDetach + kPreAttach = 0x0, + kPostAttach = 0x1, + kPreDetach = 0x2, + kPostDetach = 0x3 }; // members @@ -208,7 +437,7 @@ namespace RE return *singleton; } }; - static_assert(sizeof(CurrentRadiationSourceCount) == 0x08); + static_assert(sizeof(CurrentRadiationSourceCount) == 0x8); struct ColorUpdateEvent { @@ -232,14 +461,14 @@ namespace RE { public: }; - static_assert(sizeof(CurrentRadsDisplayMagnitude) == 0x08); + static_assert(sizeof(CurrentRadsDisplayMagnitude) == 0x8); class CurrentRadsPercentOfLethal : public BSTValueEvent { public: }; - static_assert(sizeof(CurrentRadsPercentOfLethal) == 0x08); + static_assert(sizeof(CurrentRadsPercentOfLethal) == 0x8); struct DoBeforeNewOrLoadCompletedEvent { @@ -256,7 +485,7 @@ namespace RE return *singleton; } }; - static_assert(sizeof(DoBeforeNewOrLoadCompletedEvent) == 0x01); + static_assert(sizeof(DoBeforeNewOrLoadCompletedEvent) == 0x1); struct HUDModeEvent { @@ -274,9 +503,9 @@ namespace RE } // members - const BSTArray* currentHUDModes; + const BSTArray* currentHUDModes; // 00 }; - static_assert(sizeof(HUDModeEvent) == 0x08); + static_assert(sizeof(HUDModeEvent) == 0x8); struct InventoryItemDisplayData { @@ -407,7 +636,7 @@ namespace RE return *singleton; } }; - static_assert(sizeof(PipboyLightEvent) == 0x02); + static_assert(sizeof(PipboyLightEvent) == 0x2); struct PlayerAmmoCounts { @@ -416,21 +645,21 @@ namespace RE std::uint32_t clipAmmo; // 00 std::uint32_t reserveAmmo; // 04 }; - static_assert(sizeof(PlayerAmmoCounts) == 0x08); + static_assert(sizeof(PlayerAmmoCounts) == 0x8); class PlayerAmmoCountEvent : public BSTValueEvent { public: }; - static_assert(sizeof(PlayerAmmoCountEvent) == 0x0C); + static_assert(sizeof(PlayerAmmoCountEvent) == 0xC); class PlayerWeaponReloadEvent : public BSTValueEvent { public: }; - static_assert(sizeof(PlayerWeaponReloadEvent) == 0x02); + static_assert(sizeof(PlayerWeaponReloadEvent) == 0x2); struct PowerArmorLightData { @@ -450,7 +679,7 @@ namespace RE // members bool lightOn; // 00 }; - static_assert(sizeof(PowerArmorLightData) == 0x01); + static_assert(sizeof(PowerArmorLightData) == 0x1); struct QuickContainerStateData { @@ -486,11 +715,11 @@ namespace RE { public: // members - BSFixedString SwfName; - const BGSSoundDescriptorForm* soundForm; - bool VATSCritAppliedAnim; - bool VATSCritFillenAnim; - bool dialogueSpeechChallengeAnim; + BSFixedString SwfName; // 00 + const BGSSoundDescriptorForm* soundForm; // 08 + bool VATSCritAppliedAnim; // 10 + bool VATSCritFillenAnim; // 11 + bool dialogueSpeechChallengeAnim; // 12 }; static_assert(sizeof(HUDPerkVaultBoyData) == 0x18); @@ -639,8 +868,8 @@ namespace RE public: enum class FurnitureEventType : std::int32_t { - kEnter, - kExit + kEnter = 0x0, + kExit = 0x1 }; [[nodiscard]] static BSTEventSource* GetEventSource() @@ -737,7 +966,7 @@ namespace RE [[nodiscard]] static BSTEventSource* GetEventSource() { using func_t = decltype(&TESHitEvent::GetEventSource); - static REL::Relocation func{ REL::ID(1411899) }; + static REL::Relocation func{ REL::ID(2201886) }; return func(); } @@ -799,6 +1028,25 @@ namespace RE }; static_assert(sizeof(TESSwitchRaceCompleteEvent) == 0x8); + namespace TESHarvestEvent + { + struct ItemHarvested + { + [[nodiscard]] static BSTEventSource* GetEventSource() + { + using func_t = decltype(&ItemHarvested::GetEventSource); + static REL::Relocation func{ REL::ID(2193351) }; + return func(); + } + + // members + const TESBoundObject* itemHarvested; // 00 + TESObjectREFR* referenceHarvested; // 08 + const Actor* harvestedBy; // 10 + }; + static_assert(sizeof(ItemHarvested) == 0x18); + }; + class TutorialEvent { public: @@ -837,20 +1085,20 @@ namespace RE struct PositionPlayerEvent { - enum EVENT_TYPE : uint32_t + enum EVENT_TYPE : std::int32_t { - PRE_POSITION_PLAYER = 0x0, - POSITION_PLAYER_PRE_UPDATE_PACKAGES = 0x1, - POSITION_PLAYER_POST_UPDATE_PACKAGES = 0x2, - POST_POSITION_PLAYER = 0x3, - FINISH_POSITION_PLAYER = 0x4, + kPrePositionPlayer = 0x0, + kPositionPlayerPreUpdatePackages = 0x1, + kPositionPlayerPostUpdatePackages = 0x2, + kPostPositionPlayer = 0x3, + kFinishPositionPlayer = 0x4, }; // members - EVENT_TYPE type; - bool NoLoadScreen; + EVENT_TYPE type; // 00 + bool NoLoadScreen; // 04 }; - static_assert(sizeof(PositionPlayerEvent) == 0x08); + static_assert(sizeof(PositionPlayerEvent) == 0x8); class TESInitScriptEvent { @@ -858,7 +1106,7 @@ namespace RE // Members TESObjectREFR* hObjectInitialized; // 00 }; - static_assert(sizeof(TESInitScriptEvent) == 0x08); + static_assert(sizeof(TESInitScriptEvent) == 0x8); class TESInitScriptEventSource : public BSTEventSource { diff --git a/CommonLibF4/include/RE/Bethesda/FormComponents.h b/CommonLibF4/include/RE/Bethesda/FormComponents.h index e452b644..ce44e2b8 100644 --- a/CommonLibF4/include/RE/Bethesda/FormComponents.h +++ b/CommonLibF4/include/RE/Bethesda/FormComponents.h @@ -144,9 +144,9 @@ namespace RE enum class ACTOR_VALUE_MODIFIER { - kPermanent, - kTemporary, - kDamage + kPermanent = 0, + kTemporary = 1, + kDamage = 2 }; class __declspec(novtable) ActorValueOwner @@ -554,27 +554,27 @@ namespace RE enum class KeywordType { - kNone, - kComponentTechLevel, - kAttachPoint, - kComponentProperty, - kInstantiationFilter, - kModAssociation, - kSound, - kAnimArchetype, - kFunctionCall, - kRecipeFilter, - kAttractionType, - kDialogueSubtype, - kQuestTarget, - kAnimFlavor, - kAnimGender, - kAnimFaceArchetype, - kQuestGroup, - kAnimInjured, - kDispelEffect, - - kTotal + kNone = 0x0, + kComponentTechLevel = 0x1, + kAttachPoint = 0x2, + kComponentProperty = 0x3, + kInstantiationFilter = 0x4, + kModAssociation = 0x5, + kSound = 0x6, + kAnimArchetype = 0x7, + kFunctionCall = 0x8, + kRecipeFilter = 0x9, + kAttractionType = 0xA, + kDialogueSubtype = 0xB, + kQuestTarget = 0xC, + kAnimFlavor = 0xD, + kAnimGender = 0xE, + kAnimFaceArchetype = 0xF, + kQuestGroup = 0x10, + kAnimInjured = 0x11, + kDispelEffect = 0x12, + + kTotal = 0x13 }; template @@ -1423,7 +1423,7 @@ namespace RE [[nodiscard]] static std::uint32_t GetFormHealth(const TESForm* a_form, const TBO_InstanceData* a_data) { using func_t = decltype(&TESHealthForm::GetFormHealth); - static REL::Relocation func{ REL::ID(1515099) }; + static REL::Relocation func{ REL::ID(2193227) }; return func(a_form, a_data); } @@ -1771,7 +1771,7 @@ namespace RE bool GetUseAll() { using func_t = decltype(&TESLeveledList::GetUseAll); - static REL::Relocation func{ REL::ID(233875) }; + static REL::Relocation func{ REL::ID(2193253) }; return func(this); } @@ -1835,10 +1835,10 @@ namespace RE enum class FIGHT_REACTION { - kNeutral = 0, - kEnemy = 1, - kAlly = 2, - kFriend = 3 + kNeutral = 0x0, + kEnemy = 0x1, + kAlly = 0x2, + kFriend = 0x3 }; struct GROUP_REACTION @@ -2061,7 +2061,7 @@ namespace RE [[nodiscard]] static float GetFormWeight(const TESForm* a_form, const TBO_InstanceData* a_data) { using func_t = float (*)(const TESForm*, const TBO_InstanceData*); - static REL::Relocation func{ REL::ID(1321341) }; + static REL::Relocation func{ REL::ID(2193446) }; return func(a_form, a_data); } diff --git a/CommonLibF4/include/RE/Bethesda/GamePlayFormulas.h b/CommonLibF4/include/RE/Bethesda/GamePlayFormulas.h index 5e61232f..1c8bee8f 100644 --- a/CommonLibF4/include/RE/Bethesda/GamePlayFormulas.h +++ b/CommonLibF4/include/RE/Bethesda/GamePlayFormulas.h @@ -21,8 +21,8 @@ namespace RE { enum class EXPERIENCE_ACTIVITY { - kKillNPC = 0, - kHackComputer = 1, + kKillNPC = 0x0, + kHackComputer = 0x1, }; inline bool CanHackGateCheck(LOCK_LEVEL a_lockLevel) @@ -52,5 +52,12 @@ namespace RE static REL::Relocation func{ REL::ID(880926) }; return func(a_lockLevel); } + + inline float CalculateItemHealthDamageBonus(float a_itemHealth) + { + using func_t = decltype(&GamePlayFormulas::CalculateItemHealthDamageBonus); + static REL::Relocation func{ REL::ID(2209087) }; + return func(a_itemHealth); + } } } diff --git a/CommonLibF4/include/RE/Bethesda/GameScript.h b/CommonLibF4/include/RE/Bethesda/GameScript.h index 2f2201d0..4805849f 100644 --- a/CommonLibF4/include/RE/Bethesda/GameScript.h +++ b/CommonLibF4/include/RE/Bethesda/GameScript.h @@ -159,37 +159,37 @@ namespace RE enum class FunctorType { - kMoveTo, - kMoveToOwnEditorLoc, - kDamageObject, - kEnable, - kDisable, - kDelete, - kSetPosition, - kSetAngle, - kSetMotionType, - kNonLatentDelete, - kMoveToPackLoc, - kSetScale, - kDropObject, - kAttachAshPile, - kAddRemoveConstraint, - kAddRemoveRagdoll, - kApplyHavokImpulse, - kResetRefr, - kSendPlayerToJail, - kAddItem, - kResurrect, - kCast, - kScrollCast, - kRemoveItem, - kWaitFor3D, - kPlayBink, - kMoveToNearestNavmesh, - kClearDestruction, - kWaitForResourceRecalc, - kRemoveComponent, - kDropRef + kMoveTo = 0x0, + kMoveToOwnEditorLoc = 0x1, + kDamageObject = 0x2, + kEnable = 0x3, + kDisable = 0x4, + kDelete = 0x5, + kSetPosition = 0x6, + kSetAngle = 0x7, + kSetMotionType = 0x8, + kNonLatentDelete = 0x9, + kMoveToPackLoc = 0xA, + kSetScale = 0xB, + kDropObject = 0xC, + kAttachAshPile = 0xD, + kAddRemoveConstraint = 0xE, + kAddRemoveRagdoll = 0xF, + kApplyHavokImpulse = 0x10, + kResetRefr = 0x11, + kSendPlayerToJail = 0x12, + kAddItem = 0x13, + kResurrect = 0x14, + kCast = 0x15, + kScrollCast = 0x16, + kRemoveItem = 0x17, + kWaitFor3D = 0x18, + kPlayBink = 0x19, + kMoveToNearestNavmesh = 0x1A, + kClearDestruction = 0x1B, + kWaitForResourceRecalc = 0x1C, + kRemoveComponent = 0x1D, + kDropRe = 0x1Ef }; virtual ~DelayFunctor(); // 00 diff --git a/CommonLibF4/include/RE/Bethesda/IMenu.h b/CommonLibF4/include/RE/Bethesda/IMenu.h index 91398f5f..3f1aa027 100644 --- a/CommonLibF4/include/RE/Bethesda/IMenu.h +++ b/CommonLibF4/include/RE/Bethesda/IMenu.h @@ -83,59 +83,59 @@ namespace RE enum class HUDColorTypes { - kNoColorMultiplier = 0, - kMenuNoColorBackground = 1, - kGameplayHUDColor = 2, - kPlayerSetColor = 3, - kPowerArmorColorOnly = 4, - kWarningColor = 5, - kAltWarningColor = 6, - kCustomColor = 7 + kNoColorMultiplier = 0x0, + kMenuNoColorBackground = 0x1, + kGameplayHUDColor = 0x2, + kPlayerSetColor = 0x3, + kPowerArmorColorOnly = 0x4, + kWarningColor = 0x5, + kAltWarningColor = 0x6, + kCustomColor = 0x7 }; enum class MENU_RENDER_CONTEXT : std::int32_t { - kMenuDelete, - kPreDisplay, - kRenderScreenspace, - kRenderCopyQuads, - kRenderImagespace, - kEnsureDisplayMenuCalled, - kPostDisplay + kMenuDelete = 0x0, + kPreDisplay = 0x1, + kRenderScreenspace = 0x2, + kRenderCopyQuads = 0x3, + kRenderImagespace = 0x4, + kEnsureDisplayMenuCalled = 0x5, + kPostDisplay = 0x6 }; enum class PIPBOY_PAGES : std::uint32_t { - kStat, - kInv, - kData, - kMap, - kRadio + kStat = 0x0, + kInv = 0x1, + kData = 0x2, + kMap = 0x3, + kRadio = 0x4 }; enum class UI_DEPTH_PRIORITY { - kUndefined, - k3DUnderHUD, // WorkshopMenu3D - kBook, // BookMenu - kScope, // ScopeMenu - kSWFLoader, - kHUD, - kStandard, // PipboyMenu, PowerArmorRenderer, HUDRainRenderer, LockpickingMenu3D - kStandard3DModel, // Container3D, WorkbenchItem3D - kPipboy, - kTerminal, - kGameMessage, - kPauseMenu, - kLoadingFader, - kLoading3DModel, // BackgroundScreenModel - kLoadingMenu, - kMessage, - kButtonBarMenu, // FlatScreenModel, HUDScreenModel - kButtonBarSupressingMenu, - kDebug, - kConsole, - kCursor + kUndefined = 0x0, + k3DUnderHUD = 0x1, // WorkshopMenu3D + kBook = 0x2, // BookMenu + kScope = 0x3, // ScopeMenu + kSWFLoader = 0x4, + kHUD = 0x5, + kStandard = 0x6, // PipboyMenu, PowerArmorRenderer, HUDRainRenderer, LockpickingMenu3D + kStandard3DModel = 0x7, // Container3D, WorkbenchItem3D + kPipboy = 0x8, + kTerminal = 0x9, + kGameMessage = 0xA, + kPauseMenu = 0xB, + kLoadingFader = 0xC, + kLoading3DModel = 0xD, // BackgroundScreenModel + kLoadingMenu = 0xE, + kMessage = 0xF, + kButtonBarMenu = 0x10, // FlatScreenModel, HUDScreenModel + kButtonBarSupressingMenu = 0x11, + kDebug = 0x12, + kConsole = 0x13, + kCursor = 0x14 }; enum class UI_MENU_FLAGS : std::uint32_t @@ -211,7 +211,7 @@ namespace RE void UpdateDataModels() { using func_t = decltype(&GameUIModel::UpdateDataModels); - static REL::Relocation func{ REL::ID(1269653) }; + static REL::Relocation func{ REL::ID(2220905) }; return func(this); } }; @@ -297,7 +297,7 @@ namespace RE virtual bool PassesRenderConditionText(MENU_RENDER_CONTEXT a_reason, const BSFixedString& a_customRendererName) const // 07 { using func_t = decltype(&IMenu::PassesRenderConditionText); - static REL::Relocation func{ REL::ID(937304) }; + static REL::Relocation func{ REL::ID(2287379) }; return func(this, a_reason, a_customRendererName); } @@ -932,10 +932,10 @@ namespace RE enum class ShowMenuState { - kConstructed = 0, - kShown, - kHidden, - kReshowOnDestructor + kConstructed = 0x0, + kShown = 0x1, + kHidden = 0x2, + kReshowOnDestructor = 0x3 }; // members @@ -1272,7 +1272,7 @@ namespace RE void UpdateData() override { using func_t = decltype(&PipboyInventoryMenu::UpdateData); - static REL::Relocation func{ REL::ID(762897) }; + static REL::Relocation func{ REL::ID(2224143) }; return func(this); } }; @@ -1500,13 +1500,13 @@ namespace RE public: enum class SORT_ON_FIELD { - kAlphabetical = 0, - kDamage = 1, - kRateOfFire = 2, - kRange = 3, - kAccuracy = 4, - kValue = 5, - kWeight = 6, + kAlphabetical = 0x0, + kDamage = 0x1, + kRateOfFire = 0x2, + kRange = 0x3, + kAccuracy = 0x4, + kValue = 0x5, + kWeight = 0x6, }; void IncrementSort() @@ -1804,6 +1804,13 @@ namespace RE virtual void ShowBuildFailureMessage(); // 1A virtual bool TryCreate() = 0; // 1B + void UpdateOptimizedAutoBuildInv() + { + using func_t = decltype(&WorkbenchMenuBase::UpdateOptimizedAutoBuildInv); + static REL::Relocation func{ REL::ID(2224955) }; + return func(this); + } + // members NiPointer sharedContainerRef; // 0E0 NiPointer workbenchContainerRef; // 0E8 @@ -1839,10 +1846,10 @@ namespace RE enum class CONFIRM_TYPE { - kSimple, - kBuild, - kScrap, - kRepairFailure + kSimple = 0, + kBuild = 1, + kScrap = 2, + kRepairFailure = 3 }; class __declspec(novtable) ICallback @@ -1860,7 +1867,7 @@ namespace RE virtual ~ICallback() = default; // 00 // add - virtual void OnAccept() = 0; // 01 + virtual void OnAccept(); // 01 F4_HEAP_REDEFINE_NEW(ICallback); @@ -1920,6 +1927,31 @@ namespace RE }; static_assert(sizeof(InitDataScrap) == 0x40); + class __declspec(novtable) InitDataRepairFailure : + public InitData // 00 + { + public: + static constexpr auto RTTI{ RTTI::ExamineConfirmMenu__InitDataRepairFailure }; + static constexpr auto VTABLE{ VTABLE::ExamineConfirmMenu__InitDataRepairFailure }; + + InitDataRepairFailure(const BSTArray>* a_requiredItems) : + InitData(GameSettingCollection::GetSingleton()->GetSetting("sCannotRepairMessage")->GetString(), "$OK", CONFIRM_TYPE::kRepairFailure), + requiredItems(a_requiredItems) + { + this->hasCancelButton = false; + stl::emplace_vtable(this); + } + + virtual ~InitDataRepairFailure() = default; // 00 + + F4_HEAP_REDEFINE_NEW(InitDataRepairFailure); + + // members + const BSTArray>* requiredItems; // 20 + BSTHashMap availableComponents; // 28 + }; + static_assert(sizeof(InitDataRepairFailure) == 0x58); + // members Scaleform::GFx::Value confirmObj; // E0 }; @@ -1951,6 +1983,72 @@ namespace RE }; static_assert(sizeof(ScrapItemCallback) == 0x18); + class __declspec(novtable) RepairFailureCallback : + public ExamineConfirmMenu::ICallback // 00 + { + public: + static constexpr auto RTTI{ RTTI::__RepairFailureCallback }; + static constexpr auto VTABLE{ VTABLE::__RepairFailureCallback }; + + RepairFailureCallback(ExamineMenu* a_thisMenu) : + ExamineConfirmMenu::ICallback(a_thisMenu) + { + stl::emplace_vtable(this); + } + + virtual ~RepairFailureCallback() = default; // 00 + + // override + virtual void OnAccept() override; // 01 + + F4_HEAP_REDEFINE_NEW(RepairFailureCallback); + }; + static_assert(sizeof(RepairFailureCallback) == 0x10); + + class __declspec(novtable) BaseBotConfirmCallback : + public ExamineConfirmMenu::ICallback // 00 + { + public: + static constexpr auto RTTI{ RTTI::__BaseBotConfirmCallback }; + static constexpr auto VTABLE{ VTABLE::__BaseBotConfirmCallback }; + + BaseBotConfirmCallback(ExamineMenu* a_thisMenu) : + ExamineConfirmMenu::ICallback(a_thisMenu) + { + stl::emplace_vtable(this); + } + + virtual ~BaseBotConfirmCallback() = default; // 00 + + // override + virtual void OnAccept() override; // 01 + + F4_HEAP_REDEFINE_NEW(BaseBotConfirmCallback); + }; + static_assert(sizeof(BaseBotConfirmCallback) == 0x10); + + class __declspec(novtable) ModConfirmCallback : + public ExamineConfirmMenu::ICallback // 00 + { + public: + static constexpr auto RTTI{ RTTI::__ModConfirmCallback }; + static constexpr auto VTABLE{ VTABLE::__ModConfirmCallback }; + + ModConfirmCallback(ExamineMenu* a_thisMenu) : + ExamineConfirmMenu::ICallback(a_thisMenu) + { + stl::emplace_vtable(this); + } + + virtual ~ModConfirmCallback() = default; // 00 + + // override + virtual void OnAccept() override; // 01 + + F4_HEAP_REDEFINE_NEW(ModConfirmCallback); + }; + static_assert(sizeof(ModConfirmCallback) == 0x10); + class __declspec(novtable) ExamineMenu : public WorkbenchMenuBase // 00 { @@ -2042,17 +2140,24 @@ namespace RE [[nodiscard]] std::uint32_t GetSelectedIndex() { using func_t = decltype(&ExamineMenu::GetSelectedIndex); - static REL::Relocation func{ REL::ID(776503) }; + static REL::Relocation func{ REL::ID(2223022) }; return func(this); } void ShowConfirmMenu(ExamineConfirmMenu::InitData* a_data, ExamineConfirmMenu::ICallback* a_callback) { using func_t = decltype(&ExamineMenu::ShowConfirmMenu); - static REL::Relocation func{ REL::ID(443081) }; + static REL::Relocation func{ REL::ID(2223081) }; return func(this, a_data, a_callback); } + void ConsumeSelectedItems(bool a_autoBuild, const BGSSoundDescriptorForm* a_consumeSound) + { + using func_t = decltype(&ExamineMenu::ConsumeSelectedItems); + static REL::Relocation func{ REL::ID(2223052) }; + return func(this, a_autoBuild, a_consumeSound); + } + // members ComponentBuilderFunctor componentFunctor; // 340 REX::EnumSet inspectModeState; // 368 diff --git a/CommonLibF4/include/RE/Bethesda/InputEvent.h b/CommonLibF4/include/RE/Bethesda/InputEvent.h index 453812b0..79b89a2a 100644 --- a/CommonLibF4/include/RE/Bethesda/InputEvent.h +++ b/CommonLibF4/include/RE/Bethesda/InputEvent.h @@ -7,23 +7,23 @@ namespace RE { enum class DIRECTION_VAL : std::int32_t { - kNone, - kUp, - kRight, - kDown, - kLeft + kNone = 0x0, + kUp = 0x1, + kRight = 0x2, + kDown = 0x3, + kLeft = 0x4 }; enum class INPUT_EVENT_TYPE : std::int32_t { - kButton, - kMouseMove, - kCursorMove, - kChar, - kThumbstick, - kDeviceConnect, - kKinect, - kNone + kButton = 0x0, + kMouseMove = 0x1, + kCursorMove = 0x2, + kChar = 0x3, + kThumbstick = 0x4, + kDeviceConnect = 0x5, + kKinect = 0x6, + kNone = 0x7 }; enum class BS_BUTTON_CODE : std::int32_t diff --git a/CommonLibF4/include/RE/Bethesda/Interface3D.h b/CommonLibF4/include/RE/Bethesda/Interface3D.h index c3c3c232..acd31c7d 100644 --- a/CommonLibF4/include/RE/Bethesda/Interface3D.h +++ b/CommonLibF4/include/RE/Bethesda/Interface3D.h @@ -23,53 +23,53 @@ namespace RE { enum class BackgroundMode { - kLive, - kStatic, - kSolidColor + kLive = 0x0, + kStatic = 0x1, + kSolidColor = 0x2 }; enum class PostEffect { - kNone, - kPipboy, - kHUDGlass, - kHUDGlassWithMod, - kModMenu, - kModMenuHighlightAll, - kModMenuHighlightAllNoPulseOrScanLines + kNone = 0x0, + kPipboy = 0x1, + kHUDGlass = 0x2, + kHUDGlassWithMod = 0x3, + kModMenu = 0x4, + kModMenuHighlightAll = 0x5, + kModMenuHighlightAllNoPulseOrScanLines = 0x6 }; enum class HighlightEffect { - kNone, - kVATS + kNone = 0x0, + kVATS = 0x1 }; enum class OffscreenMenuSize { - kPipboy, - kFullFrame, - kFullFrameText + kPipboy = 0x0, + kFullFrame = 0x1, + kFullFrameText = 0x2 }; enum class ScreenMode { - kNone, - kWorldAttached, - kScreenAttached + kNone = 0x0, + kWorldAttached = 0x1, + kScreenAttached = 0x2 }; enum class OffscreenMenuBlendMode { - kAdditive, - kAlpha + kAdditive = 0x0, + kAlpha = 0x1 }; enum class LightType { - kSpot, - kShadowSpot, - kPoint + kSpot = 0x0, + kShadowSpot = 0x1, + kPoint = 0x2 }; class OldScreenEffectControl diff --git a/CommonLibF4/include/RE/Bethesda/InventoryUserUIUtils.h b/CommonLibF4/include/RE/Bethesda/InventoryUserUIUtils.h index 7ebcb417..5953bb6a 100644 --- a/CommonLibF4/include/RE/Bethesda/InventoryUserUIUtils.h +++ b/CommonLibF4/include/RE/Bethesda/InventoryUserUIUtils.h @@ -41,7 +41,7 @@ namespace RE float a_compareDamage = FLT_MAX) { using func_t = decltype(&detail::AddItemCardInfoEntry); - static REL::Relocation func{ REL::ID(489521) }; + static REL::Relocation func{ REL::ID(2222648) }; return func(a_array, a_newEntry, a_textID, a_value, a_difference, a_totalDamage, a_compareDamage); } } @@ -87,7 +87,7 @@ namespace RE inline void PlayPipboySound(const char* a_soundName) { using func_t = decltype(&PlayPipboySound); - static REL::Relocation func{ REL::ID(1320952) }; + static REL::Relocation func{ REL::ID(2249706) }; return func(a_soundName); } diff --git a/CommonLibF4/include/RE/Bethesda/MagicItems.h b/CommonLibF4/include/RE/Bethesda/MagicItems.h index ae3d3cd5..6a4bebbd 100644 --- a/CommonLibF4/include/RE/Bethesda/MagicItems.h +++ b/CommonLibF4/include/RE/Bethesda/MagicItems.h @@ -31,7 +31,7 @@ namespace RE void GetDescription(BSStringT* a_buffer, const char* a_beginTagFormat, const char* a_endTagFormat, float a_magnitude, float a_duration) { using func_t = decltype(&EffectItem::GetDescription); - static REL::Relocation func{ REL::ID(949839) }; + static REL::Relocation func{ REL::ID(2189612) }; return func(this, a_buffer, a_beginTagFormat, a_endTagFormat, a_magnitude, a_duration); } diff --git a/CommonLibF4/include/RE/Bethesda/MenuTopicManager.h b/CommonLibF4/include/RE/Bethesda/MenuTopicManager.h index 8984fc26..e57c888c 100644 --- a/CommonLibF4/include/RE/Bethesda/MenuTopicManager.h +++ b/CommonLibF4/include/RE/Bethesda/MenuTopicManager.h @@ -13,7 +13,7 @@ namespace RE [[nodiscard]] static MenuTopicManager* GetSingleton() { - static REL::Relocation singleton{ REL::ID(520890) }; // TODO: Update + static REL::Relocation singleton{ REL::ID(2689089) }; return *singleton; } diff --git a/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h b/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h index d5aaff3a..b5b9eafb 100644 --- a/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h +++ b/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h @@ -13,40 +13,40 @@ namespace RE enum class WARNING_TYPES { - kDefault, - kSystem, - kCombat, - kAnimation, - kAI, - kScripts, - kSaveLoad, - kDialogue, - kQuests, - kPackages, - kEditor, - kModels, - kTextures, - kPlugins, - kMasterFile, - kForms, - kMagic, - kShaders, - kRendering, - kPathfinding, - kMenus, - kAudio, - kCells, - kHavok, - kFaceGen, - kWater, - kInGameMessage, - kMemory, - kPerformance, - kLootJoy, - kVATS, - kDismember, - kCompanion, - kWorkshop, + kDefault = 0x0, + kSystem = 0x1, + kCombat = 0x2, + kAnimation = 0x3, + kAI = 0x4, + kScripts = 0x5, + kSaveLoad = 0x6, + kDialogue = 0x7, + kQuests = 0x8, + kPackages = 0x9, + kEditor = 0xA, + kModels = 0xB, + kTextures = 0xC, + kPlugins = 0xD, + kMasterFile = 0xE, + kForms = 0xF, + kMagic = 0x10, + kShaders = 0x11, + kRendering = 0x12, + kPathfinding = 0x13, + kMenus = 0x14, + kAudio = 0x15, + kCells = 0x16, + kHavok = 0x17, + kFaceGen = 0x18, + kWater = 0x19, + kInGameMessage = 0x1A, + kMemory = 0x1B, + kPerformance = 0x1C, + kLootJoy = 0x1D, + kVATS = 0x1E, + kDismember = 0x1F, + kCompanion = 0x20, + kWorkshop = 0x21, }; class alignas(0x10) IMessageBoxCallback : @@ -88,7 +88,7 @@ namespace RE public: [[nodiscard]] static MessageMenuManager* GetSingleton() { - static REL::Relocation singleton{ REL::ID(959572) }; + static REL::Relocation singleton{ REL::ID(2689087) }; return *singleton; } @@ -104,7 +104,7 @@ namespace RE bool a_ensureUnique = false) { using func_t = decltype(&MessageMenuManager::Create); - static REL::Relocation func{ REL::ID(89563) }; + static REL::Relocation func{ REL::ID(2249456) }; return func(this, a_headerText, a_bodyText, a_callback, a_warningContext, a_button1Text, a_button2Text, a_button3Text, a_button4Text, a_ensureUnique); } diff --git a/CommonLibF4/include/RE/Bethesda/PipboyArray.h b/CommonLibF4/include/RE/Bethesda/PipboyArray.h new file mode 100644 index 00000000..d1cb07a1 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyArray.h @@ -0,0 +1,21 @@ +#pragma once + +#include "RE/Bethesda/PipboyValue.h" + +namespace RE +{ + class PipboyArray : + public PipboyValue // 00 + { + public: + static constexpr auto RTTI{ RTTI::PipboyArray }; + static constexpr auto VTABLE{ VTABLE::PipboyArray }; + + // members + BSTArray elements; // 18 + BSTSet addedElementIDs; // 30 + BSTArray removedElementIDs; // 60 + bool newlyCreated; // 78 + }; + static_assert(sizeof(PipboyArray) == 0x80); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h b/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h index 8f8759da..8b2467f3 100644 --- a/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h +++ b/CommonLibF4/include/RE/Bethesda/PipboyDataGroup.h @@ -2,12 +2,11 @@ #include "RE/Bethesda/BSTEvent.h" #include "RE/Bethesda/IMenu.h" +#include "RE/Bethesda/PipboyThrottleManager.h" #include "RE/Bethesda/PipboyValue.h" namespace RE { - class PipboyThrottleManager; - class PipboyDataGroup : public BSTEventSource // 00 { @@ -15,7 +14,7 @@ namespace RE static constexpr auto RTTI{ RTTI::PipboyDataGroup }; static constexpr auto VTABLE{ VTABLE::PipboyDataGroup }; - virtual ~PipboyDataGroup(); // 00 + virtual ~PipboyDataGroup() = default; // 00 // override virtual BSEventNotifyControl ProcessEvent(const PipboyValueChangedEvent& a_event, BSTEventSource* a_source); // 01 diff --git a/CommonLibF4/include/RE/Bethesda/PipboyDataManager.h b/CommonLibF4/include/RE/Bethesda/PipboyDataManager.h new file mode 100644 index 00000000..7caab82c --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyDataManager.h @@ -0,0 +1,49 @@ +#pragma once + +#include "RE/Bethesda/BSTSingleton.h" + +#include "RE/Bethesda/PipboyDataGroup.h" +#include "RE/Bethesda/PipboyInventoryData.h" +#include "RE/Bethesda/PipboyLogData.h" +#include "RE/Bethesda/PipboyMapData.h" +#include "RE/Bethesda/PipboyPerksData.h" +#include "RE/Bethesda/PipboyPlayerInfoData.h" +#include "RE/Bethesda/PipboyQuestData.h" +#include "RE/Bethesda/PipboyRadioData.h" +#include "RE/Bethesda/PipboySpecialData.h" +#include "RE/Bethesda/PipboyStatsData.h" +#include "RE/Bethesda/PipboyStatusData.h" +#include "RE/Bethesda/PipboyThrottleManager.h" +#include "RE/Bethesda/PipboyValue.h" +#include "RE/Bethesda/PipboyWorkshopData.h" + +namespace RE +{ + class _declspec(novtable) PipboyDataManager : + public BSTSingletonSDM // 00 + { + public: + [[nodiscard]] static PipboyDataManager* GetSingleton() + { + static REL::Relocation singleton{ REL::ID(2689086) }; + return *singleton; + } + + // members + PipboyObject rootObject; // 08 + PipboyStatsData statsData; // A0 + PipboySpecialData specialData; // 1D8 + PipboyPerksData perksData; // 280 + PipboyInventoryData inventoryData; // 358 + PipboyQuestData questData; // 4F0 + PipboyWorkshopData workshopData; // 5D8 + PipboyLogData logData; // 718 + PipboyMapData mapData; // 7F0 + PipboyRadioData radioData; // A28 + PipboyPlayerInfoData playerInfoData; // AD8 + PipboyStatusData statusData; // BE0 + PipboyDataGroup* dataGroups[11]; // CC0 + PipboyThrottleManager throttleManager; // D18 + }; + static_assert(sizeof(PipboyDataManager) == 0xD48); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyInventoryData.h b/CommonLibF4/include/RE/Bethesda/PipboyInventoryData.h new file mode 100644 index 00000000..0d4d76c0 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyInventoryData.h @@ -0,0 +1,112 @@ +#pragma once + +#include "RE/Bethesda/BGSInventoryInterface.h" +#include "RE/Bethesda/BSTArray.h" +#include "RE/Bethesda/BSTEvent.h" +#include "RE/Bethesda/BSTHashMap.h" +#include "RE/Bethesda/BSTList.h" +#include "RE/Bethesda/Events.h" +#include "RE/Bethesda/PipboyArray.h" +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class PipboyInventoryData : + public PipboyDataGroup, // 00 + public BSTEventSink, // 98 + public BSTEventSink, // A0 + public BSTEventSink, // A8 + public BSTEventSink, // B0 + public BSTEventSink, // B8 + public BSTEventSink, // C0 + public BSTEventSink, // C8 + public BSTEventSink, // D0 + public BSTEventSink, // D8 + public BSTEventSink // E0 + { + public: + static constexpr auto RTTI{ RTTI::PipboyInventoryData }; + static constexpr auto VTABLE{ VTABLE::PipboyInventoryData }; + + virtual ~PipboyInventoryData(); + + enum ENTRY_TYPE + { + ENTRY_INT = 0x0, + ENTRY_FIXED_STRING = 0x1, + ENTRY_FLOAT = 0x1 + }; + + enum SORT_ON_FIELD + { + SOF_ALPHABETICALLY = 0x0, + SOF_DAMAGE = 0x1, + SOF_ROF = 0x2, + SOF_RANGE = 0x3, + SOF_ACCURARY = 0x4, + SOF_VALUE = 0x5, + SOF_WEIGHT = 0x6 + }; + + struct StackEntry + { + PipboyObject* linkedObject; // 00 + const InventoryInterface::Handle inventoryHandle; // 08 + }; + static_assert(sizeof(StackEntry) == 0x10); + + struct ItemEntry + { + void* stackEntries; // 00 - BSTList + }; + static_assert(sizeof(ItemEntry) == 0x8); + + // override + virtual BSEventNotifyControl ProcessEvent(const PipboyValueChangedEvent& a_event, BSTEventSource* a_source); // 01 + + // add + virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource* a_source); // 02 + virtual BSEventNotifyControl ProcessEvent(const ActorEquipManagerEvent::Event& a_event, BSTEventSource* a_source); // 03 + virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource* a_source); // 04 + virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkEntryUpdatedEvent& a_event, BSTEventSource* a_source); // 05 + virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkValueChangedEvent& a_event, BSTEventSource* a_source); // 06 + virtual BSEventNotifyControl ProcessEvent(const InventoryInterface::FavoriteChangedEvent& a_event, BSTEventSource* a_source); // 07 + virtual BSEventNotifyControl ProcessEvent(const HolotapeStateChanged::Event& a_event, BSTEventSource* a_source); // 08 + virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource* a_source); // 09 + virtual BSEventNotifyControl ProcessEvent(const FavoriteMgr_Events::ComponentFavoriteEvent& a_event, BSTEventSource* a_source); // 0A + virtual BSEventNotifyControl ProcessEvent(const PlayerDifficultySettingChanged::Event& a_event, BSTEventSource* a_source); // 0B + + virtual void Populate(bool a_arg1); // 0C + virtual void DoClearData(); // 0D + virtual void DoClearSink(); // 0E + + void RepopulateItemCardsOnSection(ENUM_FORM_ID itemTypeID) + { + using func_t = decltype(&PipboyInventoryData::RepopulateItemCardsOnSection); + static REL::Relocation func{ REL::ID(2225279) }; + return func(this, itemTypeID); + } + + void PopulateItemCardInfo(const BGSInventoryItem* a_inventoryItem, const BGSInventoryItem::Stack* a_stack, PipboyObject* a_data) + { + using func_t = decltype(&PipboyInventoryData::PopulateItemCardInfo); + static REL::Relocation func{ REL::ID(2225266) }; + return func(this, a_inventoryItem, a_stack, a_data); + } + + void AddItemCardInfoEntry(const BSFixedStringCS* a_string, float a_value, PipboyArray* a_itemCardSection) + { + using func_t = decltype(&PipboyInventoryData::AddItemCardInfoEntry); + static REL::Relocation func{ REL::ID(2225267) }; + return func(this, a_string, a_value, a_itemCardSection); + } + + // members + PipboyObject* inventoryObject; // E8 + BSTHashMap itemEntries; // F0 + BSTHashMap invComponents; // 120 + BSTArray sortedItems; // 150 + BSTSet queuedRepopulateCategories; // 168 + }; + static_assert(sizeof(PipboyInventoryData) == 0x198); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyLogData.h b/CommonLibF4/include/RE/Bethesda/PipboyLogData.h new file mode 100644 index 00000000..97e0a3da --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyLogData.h @@ -0,0 +1,29 @@ +#pragma once + +#include "RE/Bethesda/PipboyArray.h" +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class __declspec(novtable) PipboyLogData : + public PipboyDataGroup, // 00 + public BSTEventSink // 98 + { + public: + static constexpr auto RTTI{ RTTI::PipboyLogData }; + static constexpr auto VTABLE{ VTABLE::PipboyLogData }; + + virtual ~PipboyLogData() = default; // 00 + + virtual BSEventNotifyControl ProcessEvent(const TESTrackedStatsEvent& a_event, BSTEventSource* a_source); // 01 + + virtual void Populate(bool a_arg1) override; // 02 + virtual void DoClearData() override; // 03 + virtual void DoClearSink() override; // 04 + + // members + PipboyArray* statTypeArray; // A0 + BSTHashMap statMap; // A8 + }; + static_assert(sizeof(PipboyLogData) == 0xD8); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyManager.h b/CommonLibF4/include/RE/Bethesda/PipboyManager.h index 7c79593b..cb289ba9 100644 --- a/CommonLibF4/include/RE/Bethesda/PipboyManager.h +++ b/CommonLibF4/include/RE/Bethesda/PipboyManager.h @@ -45,10 +45,10 @@ namespace RE enum class LOWER_REASON { - kNone = 0, - kBook = 1, - kPerkGrid = 2, - kInspect = 3 + kNone = 0x0, + kBook = 0x1, + kPerkGrid = 0x2, + kInspect = 0x3 }; virtual ~PipboyManager(); // 00 @@ -62,63 +62,56 @@ namespace RE [[nodiscard]] static PipboyManager* GetSingleton() { - static REL::Relocation singleton{ REL::ID(553234) }; + static REL::Relocation singleton{ REL::ID(2691945) }; return *singleton; } void AddMenuToPipboy(IMenu& a_menu, const NiRect& a_standVP, const NiRect& a_powerVP) { using func_t = decltype(&PipboyManager::AddMenuToPipboy); - static REL::Relocation func{ REL::ID(394568) }; + static REL::Relocation func{ REL::ID(2225453) }; return func(this, a_menu, a_standVP, a_powerVP); } void ClosedownPipboy() { using func_t = decltype(&PipboyManager::ClosedownPipboy); - static REL::Relocation func{ REL::ID(731410) }; - return func(this); - } - - void DisablePipboyShader() - { - using func_t = decltype(&PipboyManager::DisablePipboyShader); - static REL::Relocation func{ REL::ID(662519) }; + static REL::Relocation func{ REL::ID(2225480) }; return func(this); } void EnablePipboyShader() { using func_t = decltype(&PipboyManager::EnablePipboyShader); - static REL::Relocation func{ REL::ID(157921) }; + static REL::Relocation func{ REL::ID(2225484) }; return func(this); } void InitPipboy() { using func_t = decltype(&PipboyManager::InitPipboy); - static REL::Relocation func{ REL::ID(1477369) }; + static REL::Relocation func{ REL::ID(2225479) }; return func(this); } void LowerPipboy(LOWER_REASON a_reason) { using func_t = decltype(&PipboyManager::LowerPipboy); - static REL::Relocation func{ REL::ID(1444875) }; + static REL::Relocation func{ REL::ID(2225454) }; return func(this, a_reason); } void OnPipboyCloseAnim() { using func_t = decltype(&PipboyManager::OnPipboyCloseAnim); - static REL::Relocation func{ REL::ID(1231000) }; + static REL::Relocation func{ REL::ID(2225457) }; return func(this); } void OnPipboyCloseAnimFailed() { using func_t = decltype(&PipboyManager::OnPipboyCloseAnimFailed); - static REL::Relocation func{ REL::ID(1362084) }; + static REL::Relocation func{ REL::ID(2225459) }; return func(this); } diff --git a/CommonLibF4/include/RE/Bethesda/PipboyMapData.h b/CommonLibF4/include/RE/Bethesda/PipboyMapData.h new file mode 100644 index 00000000..b07afb17 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyMapData.h @@ -0,0 +1,63 @@ +#pragma once + +#include "RE/Bethesda/BSTHashMap.h" +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class __declspec(novtable) PipboyMapData : + public PipboyDataGroup, // 00 + public BSTEventSink, // 98 + public BSTEventSink, // A0 + public BSTEventSink, // A8 + public BSTEventSink, // B0 + public BSTEventSink, // B8 + public BSTEventSink, // C0 + public BSTEventSink, // C8 + public BSTEventSink, // D0 + public BSTEventSink, // D8 + public BSTEventSink // E0 + { + public: + static constexpr auto RTTI{ RTTI::PipboyMapData }; + static constexpr auto VTABLE{ VTABLE::PipboyMapData }; + + virtual ~PipboyMapData() = default; + + virtual BSEventNotifyControl ProcessEvent(const TravelMarkerStateChange::Event& a_event, BSTEventSource* a_source); // 01 + virtual BSEventNotifyControl ProcessEvent(const PlayerUpdateEvent& a_event, BSTEventSource* a_source); // 02 + virtual BSEventNotifyControl ProcessEvent(const BGSActorCellEvent& a_event, BSTEventSource* a_source); // 03 + virtual BSEventNotifyControl ProcessEvent(const TESQuestEvent::Event& a_event, BSTEventSource* a_source); // 04 + virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource* a_source); // 05 + virtual BSEventNotifyControl ProcessEvent(const CustomMarkerUpdate::Event& a_event, BSTEventSource* a_source); // 06 + virtual BSEventNotifyControl ProcessEvent(const LocationMarkerArrayUpdate::Event& a_event, BSTEventSource* a_source); // 07 + virtual BSEventNotifyControl ProcessEvent(const LocalMapCameraUpdate::Event& a_event, BSTEventSource* a_source); // 08 + virtual BSEventNotifyControl ProcessEvent(const TESLocationClearedEvent& a_event, BSTEventSource* a_source); // 09 + virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource* a_source); // 0A + + // override + virtual void Populate(bool a_arg1) override; // 0B + virtual void DoClearData() override; // 0C + virtual void DoClearSink() override; // 0D + + // members + PipboyObject* mapObject; // E8 + BSTHashMap travelLocationsMarkers; // F0 + BSTHashMap>> travelLocationRefrHandles; // 120 + BSTArray doorMarkers; // 150 + BSTArray>> doorRefHandles; // 168 + BSTHashMap>, PipboyObject*> localQuestMarkers; // 180 + BSTHashMap>, PipboyObject*> worldQuestMarkers; // 1B0 + NiPoint3 playerLastLocationPosition; // 1E0 + NiPoint3 playerLastWorldPosition; // 1EC + PipboyObject* localPlayerMarker; // 1F8 + PipboyObject* worldPlayerMarker; // 200 + PipboyObject* localCustomMarker; // 208 + PipboyObject* worldCustomMarker; // 210 + PipboyObject* localPowerArmorMarker; // 218 + PipboyObject* worldPowerArmorMarker; // 220 + PipboyObject* worldMapExtents; // 230 + PipboyObject* localMapExtents; // 238 + }; + static_assert(sizeof(PipboyMapData) == 0x238); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyPerksData.h b/CommonLibF4/include/RE/Bethesda/PipboyPerksData.h new file mode 100644 index 00000000..415e730c --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyPerksData.h @@ -0,0 +1,30 @@ +#pragma once + +#include "RE/Bethesda/PipboyArray.h" +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class __declspec(novtable) PipboyPerksData : + public PipboyDataGroup, // 00 + public BSTEventSink // 98 + { + public: + static constexpr auto RTTI{ RTTI::PipboyPerksData }; + static constexpr auto VTABLE{ VTABLE::PipboyPerksData }; + + virtual ~PipboyPerksData() = default; + + virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkValueChangedEvent& a_event, BSTEventSource* a_source); // 01 + + // override + virtual void Populate(bool a_arg1) override; // 02 + virtual void DoClearData() override; // 03 + virtual void DoClearSink() override; // 04 + + PipboyArray* perkChains; // A0 + BSTArray perkChainRoots; // A8 + BSTArray perksArray; // C0 + }; + static_assert(sizeof(PipboyPerksData) == 0xD8); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyPlayerInfoData.h b/CommonLibF4/include/RE/Bethesda/PipboyPlayerInfoData.h new file mode 100644 index 00000000..41b1a9a6 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyPlayerInfoData.h @@ -0,0 +1,52 @@ +#pragma once + +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class __declspec(novtable) PipboyPlayerInfoData : + public PipboyDataGroup, // 00 + public BSTEventSink, // 98 + public BSTEventSink, // A0 + public BSTEventSink, // A8 + public BSTEventSink, // B0 + public BSTEventSink, // B8 + public BSTEventSink, // C0 + public BSTEventSink, // C8 + public BSTEventSink, // D0 + public BSTEventSink, // D8 + public BSTEventSink, // E0 + public BSTEventSink, // E8 + public BSTEventSink, // F0 + public BSTEventSink // F8 + { + public: + static constexpr auto RTTI{ RTTI::PipboyPlayerInfoData }; + static constexpr auto VTABLE{ VTABLE::PipboyPlayerInfoData }; + + virtual ~PipboyPlayerInfoData() = default; + + virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource* a_source); // 01 + virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource* a_source); // 02 + virtual BSEventNotifyControl ProcessEvent(const ActorEquipManagerEvent::Event& a_event, BSTEventSource* a_source); // 03 + virtual BSEventNotifyControl ProcessEvent(const LevelIncrease::Event& a_event, BSTEventSource* a_source); // 04 + virtual BSEventNotifyControl ProcessEvent(const PerkPointIncreaseEvent& a_event, BSTEventSource* a_source); // 05 + virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkEntryUpdatedEvent& a_event, BSTEventSource* a_source); // 06 + virtual BSEventNotifyControl ProcessEvent(const HourPassed::Event& a_event, BSTEventSource* a_source); // 07 + virtual BSEventNotifyControl ProcessEvent(const SPECIALMenuEvent::NameChangedEvent& a_event, BSTEventSource* a_source); // 08 + virtual BSEventNotifyControl ProcessEvent(const PlayerUpdateEvent& a_event, BSTEventSource* a_source); // 09 + virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource* a_source); // 0A + virtual BSEventNotifyControl ProcessEvent(const PlayerActiveEffectChanged::Event& a_event, BSTEventSource* a_source); // 0B + virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource* a_source); // 0C + virtual BSEventNotifyControl ProcessEvent(const PlayerDifficultySettingChanged::Event& a_event, BSTEventSource* a_source); // 0D + + // override + virtual void Populate(bool a_arg1) override; // 0E + virtual void DoClearData() override; // 0F + virtual void DoClearSink() override; // 10 + + // members + PipboyObject* playerInfoObject; + }; + static_assert(sizeof(PipboyPlayerInfoData) == 0x108); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyPrimitiveValue.h b/CommonLibF4/include/RE/Bethesda/PipboyPrimitiveValue.h new file mode 100644 index 00000000..ab4c6376 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyPrimitiveValue.h @@ -0,0 +1,73 @@ +#pragma once + +#include "RE/Bethesda/PipboyValue.h" + +namespace RE +{ + template + class PipboyPrimitiveValue; // Forward declaration for specialization **only** + + template <> + class __declspec(novtable) PipboyPrimitiveValue : public PipboyValue + { + public: + virtual ~PipboyPrimitiveValue() {} // 00 + + // override + virtual void CleanDirtyToGame() override {} // 00 + virtual void Serialize([[maybe_unused]] Json::Value* a_json) override {} // 01 + virtual void SerializeChanges([[maybe_unused]] BSBinarySerializer& a_serializer, [[maybe_unused]] bool a_fullSerialization) override {} // 03 + virtual SERIALIZATION_DATA_TYPE GetType() override { return SERIALIZATION_DATA_TYPE::kUint32; } + + PipboyPrimitiveValue(std::uint32_t a_value, PipboyValue* a_parentValue) : + PipboyValue(a_parentValue), value(a_value) {} + + void ctor(std::uint32_t a_value, PipboyValue* a_parentValue) + { + using func_t = decltype(&PipboyPrimitiveValue::ctor); + REL::Relocation func{ REL::ID(2225324) }; + func(this, a_value, a_parentValue); + } + + operator std::uint32_t() const + { + return value; + } + + // members + std::uint32_t value; // 18 + }; + static_assert(sizeof(PipboyPrimitiveValue) == 0x20); + + template <> + class __declspec(novtable) PipboyPrimitiveValue : public PipboyValue + { + public: + virtual ~PipboyPrimitiveValue() {} // 00 + + // override + virtual void CleanDirtyToGame() override {} // 00 + virtual void Serialize([[maybe_unused]] Json::Value* a_json) override {} // 01 + virtual void SerializeChanges([[maybe_unused]] BSBinarySerializer& a_serializer, [[maybe_unused]] bool a_fullSerialization) override {} // 03 + virtual SERIALIZATION_DATA_TYPE GetType() override { return SERIALIZATION_DATA_TYPE::kBool; } + + PipboyPrimitiveValue(bool a_value, PipboyValue* a_parentValue) : + PipboyValue(a_parentValue), value(a_value) {} + + void ctor(bool a_value, PipboyValue* a_parentValue) + { + using func_t = decltype(&PipboyPrimitiveValue::ctor); + REL::Relocation func{ REL::ID(2225327) }; + func(this, a_value, a_parentValue); + } + + operator bool() const + { + return value; + } + + // members + bool value; // 18 + }; + static_assert(sizeof(PipboyPrimitiveValue) == 0x20); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyQuestData.h b/CommonLibF4/include/RE/Bethesda/PipboyQuestData.h new file mode 100644 index 00000000..5e4cc222 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyQuestData.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/Bethesda/PipboyArray.h" +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class __declspec(novtable) PipboyQuestData : + public PipboyDataGroup, // 00 + public BSTEventSink, // 89 + public BSTEventSink // A0 + { + public: + static constexpr auto RTTI{ RTTI::PipboyQuestData }; + static constexpr auto VTABLE{ VTABLE::PipboyQuestData }; + + virtual ~PipboyQuestData(); + + virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource* a_source); // 01 + virtual BSEventNotifyControl ProcessEvent(const TESQuestEvent::Event& a_event, BSTEventSource* a_source); // 02 + + virtual void Populate(bool a_arg1) override; // 03 + virtual void DoClearData() override; // 04 + virtual void DoClearSink() override; // 05 + + // members + std::uint32_t sortIndex; // A8 + PipboyArray* questArray; // B0 + //BSTHashMap, BSTArray*> objectivesByQuest; // B8 + void* unk[6]; + }; + static_assert(sizeof(PipboyQuestData) == 0xE8); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyRadioData.h b/CommonLibF4/include/RE/Bethesda/PipboyRadioData.h new file mode 100644 index 00000000..97522b00 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyRadioData.h @@ -0,0 +1,36 @@ +#pragma once + +#include "RE/Bethesda/PipboyArray.h" +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + namespace RadioManager + { + struct PipboyFrequencyDetectionEvent; + struct PipboyRadioTuningEvent; + } + + class __declspec(novtable) PipboyRadioData : + public PipboyDataGroup, // 00 + public BSTEventSink, // 98 + public BSTEventSink // A0 + { + public: + static constexpr auto RTTI{ RTTI::PipboyRadioData }; + static constexpr auto VTABLE{ VTABLE::PipboyRadioData }; + + virtual ~PipboyRadioData() = default; + + virtual BSEventNotifyControl ProcessEvent(const RadioManager::PipboyFrequencyDetectionEvent& a_event, BSTEventSource* a_source); // 01 + virtual BSEventNotifyControl ProcessEvent(const RadioManager::PipboyRadioTuningEvent& a_event, BSTEventSource* a_source); // 02 + + virtual void Populate(bool a_arg1) override; // 03 + virtual void DoClearData() override; // 04 + virtual void DoClearSink() override; // 05 + + // members + PipboyArray* radioStations; // A8 + }; + static_assert(sizeof(PipboyRadioData) == 0xB0); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboySpecialData.h b/CommonLibF4/include/RE/Bethesda/PipboySpecialData.h new file mode 100644 index 00000000..d6eaa21d --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboySpecialData.h @@ -0,0 +1,30 @@ +#pragma once + +#include "RE/Bethesda/PipboyArray.h" +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class __declspec(novtable) PipboySpecialData : + public PipboyDataGroup, // 00 + public BSTEventSink // 98 + { + public: + static constexpr auto RTTI{ RTTI::PipboySpecialData }; + static constexpr auto VTABLE{ VTABLE::PipboySpecialData }; + + virtual ~PipboySpecialData(); + + // override + virtual void Populate(bool a_arg1) override; // 01 + virtual void DoClearData() override; // 02 + virtual void DoClearSink() override; // 03 + + // add + virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource* a_source); // 04 + + // members + PipboyArray* specialsArray; // A0 + }; + static_assert(sizeof(PipboySpecialData) == 0xA8); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyStatsData.h b/CommonLibF4/include/RE/Bethesda/PipboyStatsData.h new file mode 100644 index 00000000..856708be --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyStatsData.h @@ -0,0 +1,44 @@ +#pragma once + +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + struct ConditionBoyEvent + {}; + + class __declspec(novtable) PipboyStatsData : + public PipboyDataGroup, // 00 + public BSTEventSink, // 98 + public BSTEventSink, // A0 + public BSTEventSink, // A8 + public BSTEventSink, // B0 + public BSTEventSink, // B8 + public BSTEventSink // C0 + { + public: + static constexpr auto RTTI{ RTTI::PipboyStatsData }; + static constexpr auto VTABLE{ VTABLE::PipboyStatsData }; + + virtual ~PipboyStatsData() = default; + + virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource* a_source); // 01 + virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource* a_source); // 02 + virtual BSEventNotifyControl ProcessEvent(const PlayerActiveEffectChanged::Event& a_event, BSTEventSource* a_source); // 03 + virtual BSEventNotifyControl ProcessEvent(const ConditionBoyEvent& a_event, BSTEventSource* a_source); // 04 + virtual BSEventNotifyControl ProcessEvent(const ActorItemEquipped::Event& a_event, BSTEventSource* a_source); // 05 + virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource* a_source); // 06 + + // override + virtual void Populate(bool a_arg1) override; // 07 + virtual void DoClearData() override; // 08 + virtual void DoClearSink() override; // 09 + + // members + PipboyObject* playerStatsObject; // C8 + PipboyArray* activeEffectsArray; // D0 + BSTHashMap activeEffectsMap; // D8 + BSTHashMap, PipboyObject*> activeEffectEntriesMap; // 108 + }; + static_assert(sizeof(PipboyStatsData) == 0x138); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyStatusData.h b/CommonLibF4/include/RE/Bethesda/PipboyStatusData.h new file mode 100644 index 00000000..ecfd19a2 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyStatusData.h @@ -0,0 +1,42 @@ +#pragma once + +#include "RE/Bethesda/PipboyDataGroup.h" +#include "RE/Bethesda/VATS.h" + +namespace RE +{ + class __declspec(novtable) PipboyStatusData : + public PipboyDataGroup, // 00 + public BSTEventSink, // 98 + public BSTEventSink, // A0 + public BSTEventSink, // A8 + public BSTEventSink, // B0 + public BSTEventSink, // B8 + public BSTEventSink, // C0 + public BSTEventSink // C8 + { + public: + static constexpr auto RTTI{ RTTI::PipboyStatusData }; + static constexpr auto VTABLE{ VTABLE::PipboyStatusData }; + + virtual ~PipboyStatusData() = default; + + virtual BSEventNotifyControl ProcessEvent(const PlayerLifeStateChanged::Event& a_event, BSTEventSource* a_source); // 01 + virtual BSEventNotifyControl ProcessEvent(const PlayerInDialogueChanged::Event& a_event, BSTEventSource* a_source); // 02 + virtual BSEventNotifyControl ProcessEvent(const MenuOpenCloseEvent& a_event, BSTEventSource* a_source); // 03 + virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource* a_source); // 04 + virtual BSEventNotifyControl ProcessEvent(const LoadingStatusChanged::Event& a_event, BSTEventSource* a_source); // 05 + virtual BSEventNotifyControl ProcessEvent(const VATSEvents::ModeChange& a_event, BSTEventSource* a_source); // 06 + virtual BSEventNotifyControl ProcessEvent(const UserEventEnabledEvent& a_event, BSTEventSource* a_source); // 07 + + // override + virtual void Populate(bool a_arg1) override; // 08 + virtual void DoClearData() override; // 09 + virtual void DoClearSink() override; // 0A + + // members + PipboyObject* statusObject; + PipboyArray* pipboyEffectColorArray; + }; + static_assert(sizeof(PipboyStatusData) == 0xE0); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyThrottleManager.h b/CommonLibF4/include/RE/Bethesda/PipboyThrottleManager.h new file mode 100644 index 00000000..85419d76 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyThrottleManager.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/Bethesda/BSTHashMap.h" + +namespace RE +{ + class IPipboyThrottledValue + { + public: + static constexpr auto RTTI{ RTTI::IPipboyThrottledValue }; + static constexpr auto VTABLE{ VTABLE::IPipboyThrottledValue }; + + // members + virtual ~IPipboyThrottledValue(); // 00 + + // add + void* Update(); // 01 + }; + static_assert(sizeof(IPipboyThrottledValue) == 0x8); + + class PipboyThrottleManager + { + BSTHashMap valueMap; + }; + static_assert(sizeof(PipboyThrottleManager) == 0x30); +} diff --git a/CommonLibF4/include/RE/Bethesda/PipboyValue.h b/CommonLibF4/include/RE/Bethesda/PipboyValue.h index 4c1217e4..9a03fba6 100644 --- a/CommonLibF4/include/RE/Bethesda/PipboyValue.h +++ b/CommonLibF4/include/RE/Bethesda/PipboyValue.h @@ -33,7 +33,7 @@ namespace RE kObject = 0x8, }; - virtual ~PipboyValue(); // 00 + virtual ~PipboyValue() = default; // 00 // add virtual void CleanDirtyToGame(); // 01 @@ -41,6 +41,18 @@ namespace RE virtual void SerializeChanges(BSBinarySerializer& a_serializer, bool a_fullSerialize); // 03 virtual SERIALIZATION_DATA_TYPE GetType() = 0; // 04 + PipboyValue(PipboyValue* a_parentValue) + { + ctor(a_parentValue); + }; + + void ctor(PipboyValue* a_parentValue) + { + using func_t = decltype(&PipboyValue::ctor); + REL::Relocation func{ REL::ID(2225915) }; + return func(this, a_parentValue); + } + // members std::uint32_t id; // 08 bool isDirtyGame; // 0C @@ -64,6 +76,20 @@ namespace RE virtual void SerializeChanges(BSBinarySerializer& a_serializer, bool a_fullSerialize) override; // 03 virtual SERIALIZATION_DATA_TYPE GetType() override; // 04 + template + T GetMember(const BSFixedString& a_name) + { + const auto it = memberMap.find(a_name); + return (it != memberMap.end()) ? static_cast(it->second) : nullptr; + } + + void AddMember(const BSFixedString* a_name, PipboyValue* a_member) + { + using func_t = decltype(&PipboyObject::AddMember); + static REL::Relocation func{ REL::ID(2225699) }; + return func(this, a_name, a_member); + } + // members BSTHashMap memberMap; // 18 BSTSet addedMemberIDs; // 48 diff --git a/CommonLibF4/include/RE/Bethesda/PipboyWorkshopData.h b/CommonLibF4/include/RE/Bethesda/PipboyWorkshopData.h new file mode 100644 index 00000000..50ddaa15 --- /dev/null +++ b/CommonLibF4/include/RE/Bethesda/PipboyWorkshopData.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/Bethesda/PipboyDataGroup.h" + +namespace RE +{ + class __declspec(novtable) PipboyWorkshopData : + public PipboyDataGroup, + public BSTEventSink, + public BSTEventSink + { + public: + static constexpr auto RTTI{ RTTI::PipboyWorkshopData }; + static constexpr auto VTABLE{ VTABLE::PipboyStatusData }; + + virtual ~PipboyWorkshopData() = default; + + virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource* a_source); // 01 + virtual BSEventNotifyControl ProcessEvent(const Workshop::WorkshopModeEvent& a_event, BSTEventSource* a_source); // 02 + + // override + virtual void Populate(bool a_arg1) override; // 03 + virtual void DoClearData() override; // 04 + virtual void DoClearSink() override; // 05 + + // members + PipboyArray* workshopArray; // A8 + BSTHashMap workshopMap; // B0 + BSTHashMap ratingUpdateFunctions; // E0 + BSTHashMap getValueFunctions; // 110 + }; + static_assert(sizeof(PipboyWorkshopData) == 0x140); +} diff --git a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h index 1eed479a..98420cac 100644 --- a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h +++ b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h @@ -244,14 +244,14 @@ namespace RE void ctor(bool a_suppressMessages, bool a_suppressAudio) { using func_t = decltype(&ScopedInventoryChangeMessageContext::ctor); - static REL::Relocation func{ REL::ID(1512872) }; + static REL::Relocation func{ REL::ID(2233292) }; return func(this, a_suppressMessages, a_suppressAudio); } void dtor() { using func_t = decltype(&ScopedInventoryChangeMessageContext::dtor); - static REL::Relocation func{ REL::ID(542100) }; + static REL::Relocation func{ REL::ID(2233293) }; return func(this); } }; diff --git a/CommonLibF4/include/RE/Bethesda/PlayerControls.h b/CommonLibF4/include/RE/Bethesda/PlayerControls.h index 979824eb..106bfdca 100644 --- a/CommonLibF4/include/RE/Bethesda/PlayerControls.h +++ b/CommonLibF4/include/RE/Bethesda/PlayerControls.h @@ -35,9 +35,9 @@ namespace RE enum class ACTIONPRIORITY { - kImperative, - kQueue, - kTry + kImperative = 0x0, + kQueue = 0x1, + kTry = 0x2 }; struct Data diff --git a/CommonLibF4/include/RE/Bethesda/Projectiles.h b/CommonLibF4/include/RE/Bethesda/Projectiles.h index ddc99dfc..8ee4d738 100644 --- a/CommonLibF4/include/RE/Bethesda/Projectiles.h +++ b/CommonLibF4/include/RE/Bethesda/Projectiles.h @@ -15,11 +15,6 @@ namespace RE enum class COL_LAYER; enum class ImpactResult; - namespace BGSBodyPartDefs - { - enum class LIMB_ENUM; - } - namespace MagicSystem { enum class CastingSource; diff --git a/CommonLibF4/include/RE/Bethesda/Script.h b/CommonLibF4/include/RE/Bethesda/Script.h index 4ffb249f..7aacd344 100644 --- a/CommonLibF4/include/RE/Bethesda/Script.h +++ b/CommonLibF4/include/RE/Bethesda/Script.h @@ -9,101 +9,101 @@ namespace RE { enum class COMPILER_NAME { - kDefault, - kSystemWindow, - kDialogue + kDefault = 0x0, + kSystemWindow = 0x1, + kDialogue = 0x2 }; enum class SCRIPT_PARAM_TYPE { - kChar, - kInt, - kFloat, - kInventoryObject, - kObjectRef, - kActorValue, - kActor, - kSpellItem, - kAxis, - kCell, - kAnimGroup, - kMagicItem, - kSound, - kTopic, - kQuest, - kRace, - kClass, - kFaction, - kSex, - kGlobal, - kFurnitureOrFormList, - kObject, - kScriptVar, - kStage, - kMapMarker, - kActorBase, - kContainerRef, - kWorlOrList, - kCrimeType, - kPackage, - kCombatStyle, - kMagicEffect, - kFormType, - kWeather, - kNPC, - kOwner, - kShaderEffect, - kFormList, - kMenuIcon, - kPerk, - kNote, - kMiscStat, - kImageSpaceMod, - kImageSpace, - kVATSValue, - kVATSValueData, - kEventFunction, - kEventFunctionMember, - kEventFunctionData, - kVoiceType, - kEncounterZone, - kIdleForm, - kMessage, - kInvObjectOrFormList, - kAlignment, - kEquipType, - kObjectOrFormList, - kMusic, - kCritStage, - kKeyword, - kRefType, - kLocation, - kForm, - kAlias, - kShout, - kWordOfPower, - kRelationshipRank, - kBGSScene, - kCastingSource, - kAssociationType, - kWardState, - kPackageDataCanBeNull, - kPackageDataNumeric, - kPackageDataReference, - kVMScriptVar, - kReferenceEffect, - kPackageDataLocation, - kSoundCategory, - kKnowableForm, - kRegion, - kAction, - kMovementIdleFromState, - kMovementIdleToState, - kVMRefOrAliasScript, - kDamageType, - kSceneAction, - kKeywordOrFormlist, - kFurnEntryType + kChar = 0x0, + kInt = 0x1, + kFloat = 0x2, + kInventoryObject = 0x3, + kObjectRef = 0x4, + kActorValue = 0x5, + kActor = 0x6, + kSpellItem = 0x7, + kAxis = 0x8, + kCell = 0x9, + kAnimGroup = 0xA, + kMagicItem = 0xB, + kSound = 0xC, + kTopic = 0xD, + kQuest = 0xE, + kRace = 0xF, + kClass = 0x10, + kFaction = 0x11, + kSex = 0x12, + kGlobal = 0x13, + kFurnitureOrFormList = 0x14, + kObject = 0x15, + kScriptVar = 0x16, + kStage = 0x17, + kMapMarker = 0x18, + kActorBase = 0x19, + kContainerRef = 0x1A, + kWorlOrList = 0x1B, + kCrimeType = 0x1C, + kPackage = 0x1D, + kCombatStyle = 0xE, + kMagicEffect = 0x1F, + kFormType = 0x20, + kWeather = 0x21, + kNPC = 0x22, + kOwner = 0x23, + kShaderEffect = 0x24, + kFormList = 0x25, + kMenuIcon = 0x26, + kPerk = 0x27, + kNote = 0x28, + kMiscStat = 0x29, + kImageSpaceMod = 0x2A, + kImageSpace = 0x2B, + kVATSValue = 0x2C, + kVATSValueData = 0x2D, + kEventFunction = 0x2E, + kEventFunctionMember = 0x2F, + kEventFunctionData = 0x30, + kVoiceType = 0x31, + kEncounterZone = 0x32, + kIdleForm = 0x33, + kMessage = 0x34, + kInvObjectOrFormList = 0x35, + kAlignment = 0x36, + kEquipType = 0x37, + kObjectOrFormList = 0x38, + kMusic = 0x39, + kCritStage = 0x3A, + kKeyword = 0x3B, + kRefType = 0x3C, + kLocation = 0x3D, + kForm = 0x3E, + kAlias = 0x3F, + kShout = 0x40, + kWordOfPower = 0x41, + kRelationshipRank = 0x42, + kBGSScene = 0x43, + kCastingSource = 0x44, + kAssociationType = 0x45, + kWardState = 0x46, + kPackageDataCanBeNull = 0x47, + kPackageDataNumeric = 0x48, + kPackageDataReference = 0x49, + kVMScriptVar = 0x4A, + kReferenceEffect = 0x4B, + kPackageDataLocation = 0x4C, + kSoundCategory = 0x4D, + kKnowableForm = 0x4E, + kRegion = 0x4F, + kAction = 0x50, + kMovementIdleFromState = 0x51, + kMovementIdleToState = 0x52, + kVMRefOrAliasScript = 0x53, + kDamageType = 0x54, + kSceneAction = 0x55, + kKeywordOrFormlist = 0x56, + kFurnEntryType = 0x57 }; enum class SCRIPT_ERROR; diff --git a/CommonLibF4/include/RE/Bethesda/Sky.h b/CommonLibF4/include/RE/Bethesda/Sky.h index 7b4e35dd..1e7a0dc4 100644 --- a/CommonLibF4/include/RE/Bethesda/Sky.h +++ b/CommonLibF4/include/RE/Bethesda/Sky.h @@ -38,12 +38,12 @@ namespace RE enum class Mode { - kNone = 0, - kInterior, - kSkyDomeOnly, - kFull, + kNone = 0x0, + kInterior = 0x1, + kSkyDomeOnly = 0x2, + kFull = 0x3, - kTotal + kTotal = 0x4 }; enum class Flags diff --git a/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h b/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h index 7edc7732..2e608a1d 100644 --- a/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h +++ b/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h @@ -229,16 +229,16 @@ namespace RE public: enum class Type { - kNone, - kCreateObject, - kWeapons, - kEnchanting, - kEnchantingExperiment, - kAlchemy, - kAlchemyExperiment, - kArmor, - kPowerArmor, - kRobotMod + kNone = 0x0, + kCreateObject = 0x1, + kWeapons = 0x2, + kEnchanting = 0x3, + kEnchantingExperiment = 0x4, + kAlchemy = 0x5, + kAlchemyExperiment = 0x6, + kArmor = 0x7, + kPowerArmor = 0x8, + kRobotMod = 0x9 }; // members @@ -342,10 +342,10 @@ namespace RE enum class SEX : std::uint32_t { kNone = static_cast>(-1), - kMale = 0, - kFemale = 1, + kMale = 0x0, + kFemale = 0x1, - kTotal = 2 + kTotal = 0x2 }; class __declspec(novtable) TESNPC : @@ -396,17 +396,10 @@ namespace RE [[nodiscard]] static BSTHashMap>& GetAlternateHeadPartListMap() { - static REL::Relocation>*> map{ REL::ID(1306546), -0x8 }; + static REL::Relocation>*> map{ REL::ID(2662368), -0x8 }; return *map; } - [[nodiscard]] static TESNPC* GetDefaultNPC(TESNPC* npc) - { - using func_t = decltype(&TESNPC::GetDefaultNPC); - static REL::Relocation func{ REL::ID(1073775) }; - return func(npc); - } - [[nodiscard]] std::span GetHeadParts(bool a_alternate = true) const { if (a_alternate && UsingAlternateHeadPartList()) { diff --git a/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h b/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h index b8a4f5dc..535a1e5b 100644 --- a/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h +++ b/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h @@ -19,10 +19,7 @@ namespace RE { enum class CHUNK_ID; - enum class SOUND_LEVEL; enum class STAGGER_MAGNITUDE; - enum class WEAPON_RUMBLE_PATTERN; - enum class WEAPONHITBEHAVIOR; class BGSObjectInstanceExtra; class NiAVObject; @@ -465,28 +462,28 @@ namespace RE enum class MELEE_ATTACK_SPEED : std::int32_t { - kVerySlow = 0, - kSlow = 1, - kMedium = 2, - kFast = 3, - kVeryFast = 4 + kVerySlow = 0x0, + kSlow = 0x1, + kMedium = 0x2, + kFast = 0x3, + kVeryFast = 0x4 }; enum class WEAPON_TYPE : std::uint8_t { kNone = 0xFF, - kHandToHand = 0, - kOneHandSword = 1, - kOneHandDagger = 2, - kOneHandAxe = 3, - kOneHandMace = 4, - kTwoHandSword = 5, - kTwoHandAxe = 6, - kBow = 7, - kStaff = 8, - kGun = 9, - kGrenade = 10, - kMine = 11, + kHandToHand = 0x0, + kOneHandSword = 0x1, + kOneHandDagger = 0x2, + kOneHandAxe = 0x3, + kOneHandMace = 0x4, + kTwoHandSword = 0x5, + kTwoHandAxe = 0x6, + kBow = 0x7, + kStaff = 0x8, + kGun = 0x9, + kGrenade = 0xA, + kMine = 0xB, }; enum class WEAPON_FLAGS : std::uint32_t @@ -516,6 +513,33 @@ namespace RE kDisableShells = 0x01000000, }; + enum class WEAPON_RUMBLE_PATTERN : std::int32_t + { + kConstant = 0x0, + kPeriodicSquare = 0x1, + kPeriodicTriangle = 0x2, + kPeriodicSawtooth = 0x3, + kPatternCount = 0x4 + }; + + enum class WEAPONHITBEHAVIOR : std::int32_t + { + kNormal = 0x0, + kDismemberOnly = 0x1, + kExplodeOnly = 0x2, + kNoDismemberOrExplode = 0x3 + }; + + enum class SOUND_LEVEL : std::int32_t + { + kLoud = 0x0, + kNormal = 0x1, + kSilent = 0x2, + kVeryLoud = 0x3, + kQuiet = 0x4, + kCount = 0x5 + }; + class __declspec(novtable) TESObjectWEAP : public TESBoundObject, // 000 public TESFullName, // 068 diff --git a/CommonLibF4/include/RE/Bethesda/TESCamera.h b/CommonLibF4/include/RE/Bethesda/TESCamera.h index 9a4e62e5..a3847fea 100644 --- a/CommonLibF4/include/RE/Bethesda/TESCamera.h +++ b/CommonLibF4/include/RE/Bethesda/TESCamera.h @@ -31,21 +31,21 @@ namespace RE { enum CameraState : std::uint32_t { - kFirstPerson, - kAutoVanity, - kVATS, - kFree, - kIronSights, - kPCTransition, - kTween, - kAnimated, - k3rdPerson, - kFurniture, - kMount, - kBleedout, - kDialogue, + kFirstPerson = 0x0, + kAutoVanity = 0x1, + kVATS = 0x2, + kFree = 0x3, + kIronSights = 0x4, + kPCTransition = 0x5, + kTween = 0x6, + kAnimated = 0x7, + k3rdPerson = 0x8, + kFurniture = 0x9, + kMount = 0xA, + kBleedout = 0xB, + kDialogue = 0xC, - kTotal + kTotal = 0xD }; }; using CameraState = CameraStates::CameraState; diff --git a/CommonLibF4/include/RE/Bethesda/TESCondition.h b/CommonLibF4/include/RE/Bethesda/TESCondition.h index b9363646..006594d3 100644 --- a/CommonLibF4/include/RE/Bethesda/TESCondition.h +++ b/CommonLibF4/include/RE/Bethesda/TESCondition.h @@ -14,27 +14,27 @@ namespace RE enum class CONDITIONITEMOBJECT : unsigned { - kSelf, - kTarget, - kRef, - kCombatTarget, - kLinkedRef, - kQuestAlias, - kPackData, - kEventData, - kCommandTarget, - kEventCameraRef, - kMyKiller + kSelf = 0x0, + kTarget = 0x1, + kRef = 0x2, + kCombatTarget = 0x3, + kLinkedRef = 0x4, + kQuestAlias = 0x5, + kPackData = 0x6, + kEventData = 0x7, + kCommandTarget = 0x8, + kEventCameraRef = 0x9, + kMyKiller = 0xA }; enum class ENUM_COMPARISON_CONDITION : std::uint8_t { - kEqual, - kNotEqual, - kGreaterThan, - kGreaterThanEqual, - kLessThan, - kLessThanEqual + kEqual = 0x0, + kNotEqual = 0x1, + kGreaterThan = 0x2, + kGreaterThanEqual = 0x3, + kLessThan = 0x4, + kLessThanEqual = 0x5 }; struct FUNCTION_DATA @@ -122,6 +122,13 @@ namespace RE return func(this, a_paramData, a_function); } + void ClearAllConditionItems() const + { + using func_t = decltype(&TESCondition::ClearAllConditionItems); + static REL::Relocation func{ REL::ID(2211988) }; + return func(this); + } + // members TESConditionItem* head; // 0 }; diff --git a/CommonLibF4/include/RE/Bethesda/TESForms.h b/CommonLibF4/include/RE/Bethesda/TESForms.h index 498e90bf..61a4c42e 100644 --- a/CommonLibF4/include/RE/Bethesda/TESForms.h +++ b/CommonLibF4/include/RE/Bethesda/TESForms.h @@ -879,7 +879,7 @@ namespace RE void SetTemporary() { using func_t = decltype(&TESForm::SetTemporary); - static REL::Relocation func{ REL::ID(482454) }; + static REL::Relocation func{ REL::ID(2193125) }; return func(this); } @@ -1243,16 +1243,16 @@ namespace RE enum class SpellContext { - kApplyOnLightning, - kApplyWhenActive + kApplyOnLightning = 0x0, + kApplyWhenActive = 0x1 }; enum class SoundType { - kDefault, - kPrecipitation, - kWind, - kThunder + kDefault = 0x0, + kPrecipitation = 0x1, + kWind = 0x2, + kThunder = 0x3 }; struct SpellData @@ -1471,15 +1471,15 @@ namespace RE enum class CELL_STATE { - kNotLoaded, - kUnloading, - kLoadingData, - kLoading, - kLoaded, - kDetaching, - kAttachQueued, - kAttaching, - kAttached + kNotLoaded = 0x0, + kUnloading = 0x1, + kLoadingData = 0x2, + kLoading = 0x3, + kLoaded = 0x4, + kDetaching = 0x5, + kAttachQueued = 0x6, + kAttaching = 0x7, + kAttached = 0x8 }; enum class Flag @@ -1520,7 +1520,7 @@ namespace RE [[nodiscard]] BGSEncounterZone* GetEncounterZone() const { using func_t = decltype(&TESObjectCELL::GetEncounterZone); - static REL::Relocation func{ REL::ID(1414637) }; + static REL::Relocation func{ REL::ID(2200242) }; return func(this); } @@ -1675,7 +1675,7 @@ namespace RE public: enum class TOPIC_INFO_FLAGS : std::uint32_t { - kNone = 0, + kNone = 0x0, kStartSceneOnEnd = 0x1, kRandom = 0x2, kSayOnce = 0x4, @@ -1723,6 +1723,13 @@ namespace RE return func(this); } + TESIdleForm* GetSpeakerIdle() + { + using func_t = decltype(&TESResponse::GetSpeakerIdle); + static REL::Relocation func{ REL::ID(2208293) }; + return func(this); + } + // Members BGSLocalizedString responseText; TESResponse* pNext; @@ -1754,23 +1761,23 @@ namespace RE enum CHARISMA_CHALLENGE_DIFFICULTY : std::uint32_t { - CC_CHALLENGE_NONE = 0x0, - CC_CHALLENGE_EASY = 0x1, - CC_CHALLENGE_MEDIUM = 0x2, - CC_CHALLENGE_HARD = 0x3, - CC_CHALLENGE_ALWAYS_SUCCEEDS = 0x4, - CC_CHALLENGE_EASY_REPEATABLE = 0x5, - CC_CHALLENGE_MEDIUM_REPEATABLE = 0x6, - CC_CHALLENGE_HARD_REPEATABLE = 0x7, - CC_CHALLENGE_COUNT = 0x8, + CC_CHALLENGE_NONE = 0, + CC_CHALLENGE_EASY = 1, + CC_CHALLENGE_MEDIUM = 2, + CC_CHALLENGE_HARD = 3, + CC_CHALLENGE_ALWAYS_SUCCEEDS = 4, + CC_CHALLENGE_EASY_REPEATABLE = 5, + CC_CHALLENGE_MEDIUM_REPEATABLE = 6, + CC_CHALLENGE_HARD_REPEATABLE = 7, + CC_CHALLENGE_COUNT = 8, }; - enum CHARISMA_CHALLENGE_SUCCESS : std::uint32_t + enum CHARISMA_CHALLENGE_SUCCESS : int32_t { - CC_SUCCESS_NONE = 0xFFFFFFFF, - CC_SUCCESS_FAIL = 0x0, - CC_SUCCESS_SUCCEED = 0x1, - CC_SUCCESS_COUNT = 0x2, + CC_SUCCESS_FAIL = 0, + CC_SUCCESS_SUCCEED = 1, + CC_SUCCESS_COUNT = 2, + CC_SUCCESS_NONE = -1, }; // Returns nullptr if no parent. @@ -1781,9 +1788,9 @@ namespace RE return func(this); } - CHARISMA_CHALLENGE_DIFFICULTY GetSpeechChallengeLevel() + CHARISMA_CHALLENGE_DIFFICULTY GetChallengeLevel() { - using func_t = decltype(&TESTopicInfo::GetSpeechChallengeLevel); + using func_t = decltype(&TESTopicInfo::GetChallengeLevel); static REL::Relocation func{ REL::ID(2208441) }; return func(this); } @@ -1795,6 +1802,11 @@ namespace RE return func(this); } + [[nodiscard]] bool IsRandom() const noexcept { return data.flags.all(TOPIC_INFO_DATA::TOPIC_INFO_FLAGS::kRandom); } + [[nodiscard]] bool IsRandomEnd() const noexcept { return data.flags.all(TOPIC_INFO_DATA::TOPIC_INFO_FLAGS::kRandomEnd); } + [[nodiscard]] bool IsSayOnce() const noexcept { return data.flags.all(TOPIC_INFO_DATA::TOPIC_INFO_FLAGS::kSayOnce); } + [[nodiscard]] bool StartSceneOnEnd() const noexcept { return data.flags.all(TOPIC_INFO_DATA::TOPIC_INFO_FLAGS::kStartSceneOnEnd); } + // members TESTopic* parentTopic; // 20 TESGlobal* resetGlobal; // 28 @@ -1808,6 +1820,13 @@ namespace RE }; static_assert(sizeof(TESTopicInfo) == 0x50); + struct TOPIC_INFO_SCENEDATA + { + BGSScene* scene; // 00 + std::uint32_t phase; // 08 + }; + static_assert(sizeof(TOPIC_INFO_SCENEDATA) == 0x10); + struct IDLE_DATA { public: @@ -2209,32 +2228,32 @@ namespace RE enum PartType { - Torso, - Head1, - Eye, - LookAt, - FlyGrab, - Head2, - LeftArm1, - LeftArm2, - RightArm1, - RightArm2, - LeftLeg1, - LeftLeg2, - LeftLeg3, - RightLeg1, - RightLeg2, - RightLeg3, - Brain, - Weapon, - Root, - COM, - Pelvis, - Camera, - OffsetRoot, - LeftFoot, - RightFoot, - FaceTargetSource + Torso = 0x0, + Head1 = 0x1, + Eye = 0x2, + LookAt = 0x3, + FlyGrab = 0x4, + Head2 = 0x5, + LeftArm1 = 0x6, + LeftArm2 = 0x7, + RightArm1 = 0x8, + RightArm2 = 0x9, + LeftLeg1 = 0xA, + LeftLeg2 = 0xB, + LeftLeg3 = 0xC, + RightLeg1 = 0xD, + RightLeg2 = 0xE, + RightLeg3 = 0xF, + Brain = 0x10, + Weapon = 0x11, + Root = 0x12, + COM = 0x13, + Pelvis = 0x14, + Camera = 0x15, + OffsetRoot = 0x16, + LeftFoot = 0x17, + RightFoot = 0x18, + FaceTargetSource = 0x19 }; // members @@ -2927,6 +2946,42 @@ namespace RE public IKeywordFormBase // 20 { public: + enum class FLAG + { + kBeginOnQuestStart = 0x0, + kStopQuestOnEnd = 0x1, + kShowAllTextInEditor = 0x2, + kRepeats = 0x3, + kInterruptible = 0x4, + kPlayerDialogue = 0x5, + kNoPlayerExitDialogue = 0x6, + kPlayerRadioStation = 0x7, + kBroadCastScene = 0x8, + kPauseActorsCurrentSceneinDialogue = 0x9, + kLookAhead = 0xA, + kAllowDialogueCamera = 0xB, + kNoFollowerIdleChatter = 0xC, + }; + + enum class BOOL_BITS + { + kActive = 0x1, + kPhaseActionDone = 0x2, + KPauseScene = 0x4, + kSceneScriptFinished = 0x8, + kNeedsToEnd = 0x10, + kRandom = 0x20, + kCombatPause = 0x40, + kDialoguePause = 0x80, + kObserveCombatPause = 0x100, + kPlayerWalkedAway = 0x200, + kNoUpdate = 0x400, + kInheritedPhases = 0x800, + kQueueActive = 0x100000, + kSceneJumpActive = 0x200000, + kGamePause = 0x400000, + }; + static constexpr auto RTTI{ RTTI::BGSScene }; static constexpr auto VTABLE{ VTABLE::BGSScene }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kSCEN }; @@ -2949,6 +3004,20 @@ namespace RE float maxREFDistanceCenter; // D8 ObjectRefHandle targetRef; // DC bool shouldNotRotateToTrack; // E0 + + void ResetAllSceneActions() + { + using func_t = decltype(&BGSScene::ResetAllSceneActions); + static REL::Relocation func{ REL::ID(2206864) }; + return func(this); + } + + void SetSceneActive(bool abFlag) + { + using func_t = decltype(&BGSScene::SetSceneActive); + static REL::Relocation func{ REL::ID(2206845) }; + return func(this, abFlag); + } }; static_assert(sizeof(BGSScene) == 0xE8); @@ -3307,9 +3376,9 @@ namespace RE static_assert(sizeof(RuleSet) == 0x18); // members - REX::EnumSet type; // 020 - RuleSet ruleSets[10]; // 028 - BSTArray mergeSources; // 118 + ENUM_FORM_ID type; // 020 + RuleSet ruleSets[10]; // 028 + BSTArray mergeSources; // 118 }; static_assert(sizeof(BGSInstanceNamingRules) == 0x130); diff --git a/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h b/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h index 6458a375..4531ca3d 100644 --- a/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h +++ b/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h @@ -24,11 +24,6 @@ namespace RE enum class CastingSource; } - namespace BGSBodyPartDefs - { - enum class LIMB_ENUM; - } - class ActorCause; class BGSAnimationSequencer; class BGSDecalGroup; @@ -100,12 +95,12 @@ namespace RE enum class ITEM_REMOVE_REASON { - kNone = 0, - kStealing = 1, - kSelling = 2, - KDropping = 3, - kStoreContainer = 4, - kStoreTeammate = 5 + kNone = 0x0, + kStealing = 0x1, + kSelling = 0x2, + KDropping = 0x3, + kStoreContainer = 0x4, + kStoreTeammate = 0x5 }; enum class RESET_3D_FLAGS @@ -345,7 +340,7 @@ namespace RE bool a_alwaysContinue = false) { using func_t = decltype(&BGSInventoryList::FindAndWriteStackDataForItem); - static REL::Relocation func{ REL::ID(1354005) }; + static REL::Relocation func{ REL::ID(2194179) }; return func(this, a_object, a_compareFunc, a_writeFunc, a_objCompFn, a_alwaysContinue); } @@ -393,22 +388,22 @@ namespace RE { kNone = static_cast>(-1), - kEditorCount = 32, + kEditorCount = 0x20, kWeaponHand = kEditorCount, - kWeaponSword, - kWeaponDagger, - kWeaponAxe, - kWeaponMace, - kWeaponTwoHandMelee, - kWeaponBow, - kWeaponStaff, - kQuiver, - kWeaponGun, - kWeaponGrenade, - kWeaponMine, - - kTotal + kWeaponSword = 0x21, + kWeaponDagger = 0x22, + kWeaponAxe = 0x23, + kWeaponMace = 0x24, + kWeaponTwoHandMelee = 0x25, + kWeaponBow = 0x26, + kWeaponStaff = 0x27, + kQuiver = 0x28, + kWeaponGun = 0x29, + kWeaponGrenade = 0x2A, + kWeaponMine = 0x2B, + + kTotal = 0x2C }; struct BIPOBJECT @@ -461,15 +456,15 @@ namespace RE enum class LOCK_LEVEL { kUnlocked = static_cast>(-1), - kEasy = 0, - kAverage = 1, - kHard = 2, - kVeryHard = 3, - kRequiresKey = 4, - kInaccessible = 5, - kTerminal = 6, - kBarred = 7, - kChained = 8, + kEasy = 0x0, + kAverage = 0x1, + kHard = 0x2, + kVeryHard = 0x3, + kRequiresKey = 0x4, + kInaccessible = 0x5, + kTerminal = 0x6, + kBarred = 0x7, + kChained = 0x8, }; struct REFR_LOCK @@ -478,7 +473,7 @@ namespace RE [[nodiscard]] LOCK_LEVEL GetLockLevel(TESObjectREFR* a_owner) { using func_t = decltype(&REFR_LOCK::GetLockLevel); - static REL::Relocation func{ REL::ID(782953) }; + static REL::Relocation func{ REL::ID(2191018) }; return func(this, a_owner); } @@ -673,7 +668,7 @@ namespace RE void AddInventoryItem(TESBoundObject* a_object, BSTSmartPointer a_extra, std::uint32_t a_count, TESObjectREFR* a_oldContainer, const INSTANCE_FILTER* a_filter, TESObjectREFR* a_overrideRef) { using func_t = decltype(&TESObjectREFR::AddInventoryItem); - static REL::Relocation func{ REL::ID(78185) }; + static REL::Relocation func{ REL::ID(2200949) }; return func(this, a_object, a_extra, a_count, a_oldContainer, a_filter, a_overrideRef); } @@ -774,7 +769,7 @@ namespace RE [[nodiscard]] std::int64_t GetGoldAmount() { using func_t = decltype(&TESObjectREFR::GetGoldAmount); - static REL::Relocation func{ REL::ID(564356) }; + static REL::Relocation func{ REL::ID(2200923) }; return func(this); } @@ -795,7 +790,7 @@ namespace RE [[nodiscard]] std::uint32_t GetInventoryObjectCount(const TESBoundObject* a_object) { using func_t = decltype(&TESObjectREFR::GetInventoryObjectCount); - static REL::Relocation func{ REL::ID(333415) }; + static REL::Relocation func{ REL::ID(2200939) }; return func(this, a_object); } @@ -907,7 +902,7 @@ namespace RE bool GetItemCount(uint32_t& count, TESForm* item, bool countComponent) { using func_t = decltype(&TESObjectREFR::GetItemCount); - static REL::Relocation func{ REL::ID(635042) }; + static REL::Relocation func{ REL::ID(2200996) }; return func(this, count, item, countComponent); } diff --git a/CommonLibF4/include/RE/Bethesda/TESRace.h b/CommonLibF4/include/RE/Bethesda/TESRace.h index 753a8075..4ec508f0 100644 --- a/CommonLibF4/include/RE/Bethesda/TESRace.h +++ b/CommonLibF4/include/RE/Bethesda/TESRace.h @@ -19,10 +19,10 @@ namespace RE enum class RACE_SIZE { - kSmall, - kMedium, - kLarge, - kExtraLarge + kSmall = 0x0, + kMedium = 0x1, + kLarge = 0x2, + kExtraLarge = 0x2 }; struct RACE_DATA diff --git a/CommonLibF4/include/RE/Bethesda/UIMessage.h b/CommonLibF4/include/RE/Bethesda/UIMessage.h index 3366b15a..adaa37a0 100644 --- a/CommonLibF4/include/RE/Bethesda/UIMessage.h +++ b/CommonLibF4/include/RE/Bethesda/UIMessage.h @@ -13,27 +13,27 @@ namespace RE enum class UI_MESSAGE_RESULTS { - kHandled, - kIgnore, - kPassOn + kHandled = 0x0, + kIgnore = 0x1, + kPassOn = 0x2 }; enum class UI_MESSAGE_TYPE { - kUpdate, - kShow, - kReshow, - kHide, - kForceHide, - kScaleformEvent, - kUserEvent, - kInventoryUpdate, - kUserProfileChange, - kMUStatusChange, - kResumeCaching, - kUpdateController, - kChatterEvent, - kTotal + kUpdate = 0x0, + kShow = 0x1, + kReshow = 0x2, + kHide = 0x3, + kForceHide = 0x4, + kScaleformEvent = 0x5, + kUserEvent = 0x6, + kInventoryUpdate = 0x7, + kUserProfileChange = 0x8, + kMUStatusChange = 0x9, + kResumeCaching = 0xA, + kUpdateController = 0xB, + kChatterEvent = 0xC, + kTotal = 0xD }; class IUIMessageData; diff --git a/CommonLibF4/include/RE/Bethesda/UserEvents.h b/CommonLibF4/include/RE/Bethesda/UserEvents.h index 35263b63..0b7b0f15 100644 --- a/CommonLibF4/include/RE/Bethesda/UserEvents.h +++ b/CommonLibF4/include/RE/Bethesda/UserEvents.h @@ -24,51 +24,51 @@ namespace RE enum class INPUT_CONTEXT_ID { - kMainGameplay = 0, - kBasicMenuNav, - kThumbNav, - kVirtualController, - kCursor, - kLThumbCursor, - kConsole, - kDebugText, - kBook, - kDebugOverlay, - kTFC, - kDebugMap, - kLockpick, - kVATS, - kVATSPlayback, - kMultiActivate, - kWorkshop, - kScope, - kSitWait, - kLooksMenu, - kWorkshopAddendum, - kPauseMenu, - kLevelUpMenu, - kLevelUpMenuPrevNext, - kMainMenu, - kQuickContainerMenu, - kSpecialActivateRollover, - kTwoButtonRollover, - kQuickContainerMenuPerk, - kVertibird, - kPlayBinkMenu, - kRobotModAddendum, - kCreationClub, + kMainGameplay = 0x0, + kBasicMenuNav = 0x1, + kThumbNav = 0x2, + kVirtualController = 0x3, + kCursor = 0x4, + kLThumbCursor = 0x5, + kConsole = 0x6, + kDebugText = 0x7, + kBook = 0x8, + kDebugOverlay = 0x9, + kTFC = 0xA, + kDebugMap = 0xB, + kLockpick = 0xC, + kVATS = 0xD, + kVATSPlayback = 0xE, + kMultiActivate = 0xF, + kWorkshop = 0x10, + kScope = 0x11, + kSitWait = 0x12, + kLooksMenu = 0x13, + kWorkshopAddendum = 0x14, + kPauseMenu = 0x15, + kLevelUpMenu = 0x16, + kLevelUpMenuPrevNext = 0x17, + kMainMenu = 0x18, + kQuickContainerMenu = 0x19, + kSpecialActivateRollover = 0x1A, + kTwoButtonRollover = 0x1B, + kQuickContainerMenuPerk = 0x1C, + kVertibird = 0x1D, + kPlayBinkMenu = 0x1E, + kRobotModAddendum = 0x1F, + kCreationClub = 0x20, - kTotal, + kTotal = 0x21, - kNone + kNone = 0x22 }; enum class SENDER_ID { - kNone, - kGameplay, - kMenu, - kScript + kNone = 0x0, + kGameplay = 0x1, + kMenu = 0x2, + kScript = 0x3 }; } diff --git a/CommonLibF4/include/RE/Bethesda/VATS.h b/CommonLibF4/include/RE/Bethesda/VATS.h index db9f580c..a47f5265 100644 --- a/CommonLibF4/include/RE/Bethesda/VATS.h +++ b/CommonLibF4/include/RE/Bethesda/VATS.h @@ -34,8 +34,8 @@ namespace RE enum class VATS_MODE_ENUM { - kNone = 0, - kPlayback = 1 + kNone = 0x0, + kPlayback = 0x1 }; virtual ~VATS(); // 00 @@ -82,4 +82,14 @@ namespace RE BSSpinLock spinLock; // D0 }; static_assert(sizeof(VATS) == 0xD8); + + namespace VATSEvents + { + struct ModeChange + { + VATS::VATS_MODE_ENUM oldMode; // 00 + VATS::VATS_MODE_ENUM newMode; // 04 + }; + static_assert(sizeof(ModeChange) == 0x8); + } } diff --git a/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h b/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h index b3305c0f..0a4f9df7 100644 --- a/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h +++ b/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h @@ -41,13 +41,13 @@ namespace RE public: enum class Preset { - STATIC = 0, ///< No velocity allowed - DYNAMIC, ///< For regular dynamic bodies, undamped and gravity factor = 1 - KEYFRAMED, ///< like DYNAMIC, but gravity factor = 0 - FROZEN, ///< like KEYFRAMED, but lots of damping - DEBRIS, ///< like DYNAMIC, but aggressive deactivation + STATIC = 0x0, ///< No velocity allowed + DYNAMIC = 0x1, ///< For regular dynamic bodies, undamped and gravity factor = 1 + KEYFRAMED = 0x2, ///< like DYNAMIC, but gravity factor = 0 + FROZEN = 0x3, ///< like KEYFRAMED, but lots of damping + DEBRIS = 0x4, ///< like DYNAMIC, but aggressive deactivation - NUM_PRESETS + NUM_PRESETS = 0x5 }; }; diff --git a/CommonLibF4/include/RE/Fallout.h b/CommonLibF4/include/RE/Fallout.h index f67f681b..7ae1cf62 100644 --- a/CommonLibF4/include/RE/Fallout.h +++ b/CommonLibF4/include/RE/Fallout.h @@ -5,6 +5,7 @@ #include "RE/Bethesda/AITimeStamp.h" #include "RE/Bethesda/ActiveEffect.h" #include "RE/Bethesda/Actor.h" +#include "RE/Bethesda/ActorUtils.h" #include "RE/Bethesda/ActorValueInfo.h" #include "RE/Bethesda/Archive2.h" #include "RE/Bethesda/Atomic.h" @@ -192,10 +193,25 @@ #include "RE/Bethesda/Movement.h" #include "RE/Bethesda/NavMesh.h" #include "RE/Bethesda/NavMeshInfoMap.h" +#include "RE/Bethesda/PipboyArray.h" #include "RE/Bethesda/PipboyDataGroup.h" +#include "RE/Bethesda/PipboyDataManager.h" +#include "RE/Bethesda/PipboyInventoryData.h" #include "RE/Bethesda/PipboyInventoryUtils.h" +#include "RE/Bethesda/PipboyLogData.h" #include "RE/Bethesda/PipboyManager.h" +#include "RE/Bethesda/PipboyMapData.h" +#include "RE/Bethesda/PipboyPerksData.h" +#include "RE/Bethesda/PipboyPlayerInfoData.h" +#include "RE/Bethesda/PipboyPrimitiveValue.h" +#include "RE/Bethesda/PipboyQuestData.h" +#include "RE/Bethesda/PipboyRadioData.h" +#include "RE/Bethesda/PipboySpecialData.h" +#include "RE/Bethesda/PipboyStatsData.h" +#include "RE/Bethesda/PipboyStatusData.h" +#include "RE/Bethesda/PipboyThrottleManager.h" #include "RE/Bethesda/PipboyValue.h" +#include "RE/Bethesda/PipboyWorkshopData.h" #include "RE/Bethesda/PlayerCharacter.h" #include "RE/Bethesda/PlayerControls.h" #include "RE/Bethesda/PowerArmor.h" diff --git a/CommonLibF4/include/RE/NetImmerse/NiController.h b/CommonLibF4/include/RE/NetImmerse/NiController.h index d32971c7..7ebac2f8 100644 --- a/CommonLibF4/include/RE/NetImmerse/NiController.h +++ b/CommonLibF4/include/RE/NetImmerse/NiController.h @@ -25,7 +25,7 @@ namespace RE [[nodiscard]] static NiControllerManager* GetNiControllerManager(const NiObjectNET* a_object) { using func_t = decltype(&NiControllerManager::GetNiControllerManager); - static REL::Relocation func{ REL::ID(1013515) }; + static REL::Relocation func{ REL::ID(2271798) }; return func(a_object); } @@ -77,7 +77,7 @@ namespace RE bool Activate(std::uint8_t a_priority, bool a_startOver, float a_weight, float a_easeInTime, NiControllerSequence* a_timeSyncSeq, bool a_transition) { using func_t = decltype(&NiControllerSequence::Activate); - static REL::Relocation func{ REL::ID(829033) }; + static REL::Relocation func{ REL::ID(2271861) }; return func(this, a_priority, a_startOver, a_weight, a_easeInTime, a_timeSyncSeq, a_transition); } diff --git a/CommonLibF4/include/RE/Scaleform/GFx/GFx_ASString.h b/CommonLibF4/include/RE/Scaleform/GFx/GFx_ASString.h index 0967f152..8c5613b5 100644 --- a/CommonLibF4/include/RE/Scaleform/GFx/GFx_ASString.h +++ b/CommonLibF4/include/RE/Scaleform/GFx/GFx_ASString.h @@ -13,7 +13,7 @@ namespace RE::Scaleform::GFx [[nodiscard]] ASStringNode* CreateStringNode(const char* a_str) { using func_t = decltype(&ASStringManager::CreateStringNode); - static REL::Relocation func{ REL::ID(419974) }; + static REL::Relocation func{ REL::ID(2290014) }; return func(this, a_str); } diff --git a/CommonLibF4/include/RE/Scaleform/GFx/GFx_Loader.h b/CommonLibF4/include/RE/Scaleform/GFx/GFx_Loader.h index f5ee0eaf..33d1f824 100644 --- a/CommonLibF4/include/RE/Scaleform/GFx/GFx_Loader.h +++ b/CommonLibF4/include/RE/Scaleform/GFx/GFx_Loader.h @@ -229,7 +229,7 @@ namespace RE::Scaleform::GFx [[nodiscard]] MovieDef* CreateMovie(const char* a_filename, Flags a_loadConstants = LoadConstants::kAll, std::size_t a_memoryArena = 0) { using func_t = decltype(&Loader::CreateMovie); - static REL::Relocation func{ REL::ID(912291) }; + static REL::Relocation func{ REL::ID(2284723) }; return func(this, a_filename, a_loadConstants, a_memoryArena); } diff --git a/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h b/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h index 22f2cf02..a0047da9 100644 --- a/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h +++ b/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h @@ -558,7 +558,7 @@ namespace RE::Scaleform::GFx bool HasMember(void* a_data, const char* a_name, bool a_isdobj) const { using func_t = decltype(&ObjectInterface::HasMember); - static REL::Relocation func{ REL::ID(788691) }; + static REL::Relocation func{ REL::ID(2286078) }; return func(this, a_data, a_name, a_isdobj); } diff --git a/CommonLibF4/include/RE/Scaleform/Kernel/SF_SysAlloc.h b/CommonLibF4/include/RE/Scaleform/Kernel/SF_SysAlloc.h index 2926ae21..1494c31f 100644 --- a/CommonLibF4/include/RE/Scaleform/Kernel/SF_SysAlloc.h +++ b/CommonLibF4/include/RE/Scaleform/Kernel/SF_SysAlloc.h @@ -37,14 +37,14 @@ namespace RE::Scaleform bool InitHeapEngine(const void* a_heapDesc) override // 01 { using func_t = decltype(&SysAlloc::InitHeapEngine); - static REL::Relocation func{ REL::ID(1047970) }; + static REL::Relocation func{ REL::ID(2284532) }; return func(this, a_heapDesc); } bool ShutdownHeapEngine() override // 02 { using func_t = decltype(&SysAlloc::ShutdownHeapEngine); - static REL::Relocation func{ REL::ID(1207169) }; + static REL::Relocation func{ REL::ID(2284536) }; return func(this); }