UltraWideFixer/ReshadePluginsCore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
3eb688ce527ad4fddd46ea455471666e86889f51
ReshadePluginsCore/The Callisto Protocol/SDK/AIModule_classes.hpp
Emmanuel AYME 2bd65090c8 Add Unreal Engine SDK
2025-12-13 18:08:13 +01:00

4538 lines
284 KiB
C++
Raw Blame History

#pragma once
/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/
// Package: AIModule
#include "Basic.hpp"
#include "AIModule_structs.hpp"
#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "GameplayTasks_classes.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "GameplayTags_structs.hpp"
#include "NavigationSystem_classes.hpp"
namespace SDK
{
// Class AIModule.EnvQueryNode
// 0x0008 (0x0030 - 0x0028)
class UEnvQueryNode : public UObject
{
public:
int32 VerNum; // 0x0028(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_2C[0x4]; // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryNode">();
}
static class UEnvQueryNode* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryNode>();
}
};
static_assert(alignof(UEnvQueryNode) == 0x000008, "Wrong alignment on UEnvQueryNode");
static_assert(sizeof(UEnvQueryNode) == 0x000030, "Wrong size on UEnvQueryNode");
static_assert(offsetof(UEnvQueryNode, VerNum) == 0x000028, "Member 'UEnvQueryNode::VerNum' has a wrong offset!");
// Class AIModule.EnvQueryGenerator
// 0x0020 (0x0050 - 0x0030)
class UEnvQueryGenerator : public UEnvQueryNode
{
public:
class FString OptionName; // 0x0030(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TSubclassOf<class UEnvQueryItemType> ItemType; // 0x0040(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 bAutoSortTests : 1; // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_49[0x7]; // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator">();
}
static class UEnvQueryGenerator* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator>();
}
};
static_assert(alignof(UEnvQueryGenerator) == 0x000008, "Wrong alignment on UEnvQueryGenerator");
static_assert(sizeof(UEnvQueryGenerator) == 0x000050, "Wrong size on UEnvQueryGenerator");
static_assert(offsetof(UEnvQueryGenerator, OptionName) == 0x000030, "Member 'UEnvQueryGenerator::OptionName' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator, ItemType) == 0x000040, "Member 'UEnvQueryGenerator::ItemType' has a wrong offset!");
// Class AIModule.AIController
// 0x0090 (0x0328 - 0x0298)
class AAIController : public AController
{
public:
uint8 Pad_298[0x38]; // 0x0298(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bStartAILogicOnPossess : 1; // 0x02D0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bStopAILogicOnUnposses : 1; // 0x02D0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bLOSflag : 1; // 0x02D0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bSkipExtraLOSChecks : 1; // 0x02D0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bAllowStrafe : 1; // 0x02D0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bWantsPlayerState : 1; // 0x02D0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bSetControlRotationFromPawnOrientation : 1; // 0x02D0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_2D1[0x7]; // 0x02D1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
class UPathFollowingComponent* PathFollowingComponent; // 0x02D8(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UBrainComponent* BrainComponent; // 0x02E0(0x0008)(BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UAIPerceptionComponent* PerceptionComponent; // 0x02E8(0x0008)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UPawnActionsComponent* ActionsComp; // 0x02F0(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UBlackboardComponent* Blackboard; // 0x02F8(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UGameplayTasksComponent* CachedGameplayTasksComponent; // 0x0300(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TSubclassOf<class UNavigationQueryFilter> DefaultNavigationFilterClass; // 0x0308(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TMulticastInlineDelegate<void(const struct FAIRequestID& RequestID, EPathFollowingResult Result)> ReceiveMoveCompleted; // 0x0310(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
uint8 Pad_320[0x8]; // 0x0320(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void ClaimTaskResource(TSubclassOf<class UGameplayTaskResource> ResourceClass);
class UAIPerceptionComponent* GetAIPerceptionComponent();
void K2_ClearFocus();
void K2_SetFocalPoint(const struct FVector& FP);
void K2_SetFocus(class AActor* NewFocus);
EPathFollowingRequestResult MoveToActor(class AActor* Goal, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bCanStrafe, TSubclassOf<class UNavigationQueryFilter> FilterClass, bool bAllowPartialPath);
EPathFollowingRequestResult MoveToLocation(const struct FVector& Dest, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bProjectDestinationToNavigation, bool bCanStrafe, TSubclassOf<class UNavigationQueryFilter> FilterClass, bool bAllowPartialPath);
void OnGameplayTaskResourcesClaimed(const struct FGameplayResourceSet& NewlyClaimed, const struct FGameplayResourceSet& FreshlyReleased);
void OnUsingBlackBoard(class UBlackboardComponent* BlackboardComp, class UBlackboardData* BlackboardAsset);
bool RunBehaviorTree(class UBehaviorTree* BTAsset);
void SetMoveBlockDetection(bool bEnable);
void SetPathFollowingComponent(class UPathFollowingComponent* NewPFComponent);
void UnclaimTaskResource(TSubclassOf<class UGameplayTaskResource> ResourceClass);
bool UseBlackboard(class UBlackboardData* BlackboardAsset, class UBlackboardComponent** BlackboardComponent);
struct FVector GetFocalPoint() const;
struct FVector GetFocalPointOnActor(const class AActor* Actor) const;
class AActor* GetFocusActor() const;
struct FVector GetImmediateMoveDestination() const;
EPathFollowingStatus GetMoveStatus() const;
class UPathFollowingComponent* GetPathFollowingComponent() const;
bool HasPartialPath() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIController">();
}
static class AAIController* GetDefaultObj()
{
return GetDefaultObjImpl<AAIController>();
}
};
static_assert(alignof(AAIController) == 0x000008, "Wrong alignment on AAIController");
static_assert(sizeof(AAIController) == 0x000328, "Wrong size on AAIController");
static_assert(offsetof(AAIController, PathFollowingComponent) == 0x0002D8, "Member 'AAIController::PathFollowingComponent' has a wrong offset!");
static_assert(offsetof(AAIController, BrainComponent) == 0x0002E0, "Member 'AAIController::BrainComponent' has a wrong offset!");
static_assert(offsetof(AAIController, PerceptionComponent) == 0x0002E8, "Member 'AAIController::PerceptionComponent' has a wrong offset!");
static_assert(offsetof(AAIController, ActionsComp) == 0x0002F0, "Member 'AAIController::ActionsComp' has a wrong offset!");
static_assert(offsetof(AAIController, Blackboard) == 0x0002F8, "Member 'AAIController::Blackboard' has a wrong offset!");
static_assert(offsetof(AAIController, CachedGameplayTasksComponent) == 0x000300, "Member 'AAIController::CachedGameplayTasksComponent' has a wrong offset!");
static_assert(offsetof(AAIController, DefaultNavigationFilterClass) == 0x000308, "Member 'AAIController::DefaultNavigationFilterClass' has a wrong offset!");
static_assert(offsetof(AAIController, ReceiveMoveCompleted) == 0x000310, "Member 'AAIController::ReceiveMoveCompleted' has a wrong offset!");
// Class AIModule.BlackboardKeyType
// 0x0008 (0x0030 - 0x0028)
class UBlackboardKeyType : public UObject
{
public:
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType">();
}
static class UBlackboardKeyType* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType>();
}
};
static_assert(alignof(UBlackboardKeyType) == 0x000008, "Wrong alignment on UBlackboardKeyType");
static_assert(sizeof(UBlackboardKeyType) == 0x000030, "Wrong size on UBlackboardKeyType");
// Class AIModule.BlackboardKeyType_NativeEnum
// 0x0018 (0x0048 - 0x0030)
class UBlackboardKeyType_NativeEnum final : public UBlackboardKeyType
{
public:
class FString EnumName; // 0x0030(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UEnum* EnumType; // 0x0040(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_NativeEnum">();
}
static class UBlackboardKeyType_NativeEnum* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_NativeEnum>();
}
};
static_assert(alignof(UBlackboardKeyType_NativeEnum) == 0x000008, "Wrong alignment on UBlackboardKeyType_NativeEnum");
static_assert(sizeof(UBlackboardKeyType_NativeEnum) == 0x000048, "Wrong size on UBlackboardKeyType_NativeEnum");
static_assert(offsetof(UBlackboardKeyType_NativeEnum, EnumName) == 0x000030, "Member 'UBlackboardKeyType_NativeEnum::EnumName' has a wrong offset!");
static_assert(offsetof(UBlackboardKeyType_NativeEnum, EnumType) == 0x000040, "Member 'UBlackboardKeyType_NativeEnum::EnumType' has a wrong offset!");
// Class AIModule.BrainComponent
// 0x0058 (0x0108 - 0x00B0)
class UBrainComponent : public UActorComponent
{
public:
uint8 Pad_B0[0x8]; // 0x00B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
class UBlackboardComponent* BlackboardComp; // 0x00B8(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class AAIController* AIOwner; // 0x00C0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_C8[0x40]; // 0x00C8(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void RestartLogic();
void StartLogic();
void StopLogic(const class FString& Reason);
bool IsPaused() const;
bool IsRunning() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BrainComponent">();
}
static class UBrainComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UBrainComponent>();
}
};
static_assert(alignof(UBrainComponent) == 0x000008, "Wrong alignment on UBrainComponent");
static_assert(sizeof(UBrainComponent) == 0x000108, "Wrong size on UBrainComponent");
static_assert(offsetof(UBrainComponent, BlackboardComp) == 0x0000B8, "Member 'UBrainComponent::BlackboardComp' has a wrong offset!");
static_assert(offsetof(UBrainComponent, AIOwner) == 0x0000C0, "Member 'UBrainComponent::AIOwner' has a wrong offset!");
// Class AIModule.BlackboardKeyType_Object
// 0x0008 (0x0038 - 0x0030)
class UBlackboardKeyType_Object final : public UBlackboardKeyType
{
public:
class UClass* BaseClass; // 0x0030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Object">();
}
static class UBlackboardKeyType_Object* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Object>();
}
};
static_assert(alignof(UBlackboardKeyType_Object) == 0x000008, "Wrong alignment on UBlackboardKeyType_Object");
static_assert(sizeof(UBlackboardKeyType_Object) == 0x000038, "Wrong size on UBlackboardKeyType_Object");
static_assert(offsetof(UBlackboardKeyType_Object, BaseClass) == 0x000030, "Member 'UBlackboardKeyType_Object::BaseClass' has a wrong offset!");
// Class AIModule.EnvQueryTest
// 0x01C8 (0x01F8 - 0x0030)
class UEnvQueryTest : public UEnvQueryNode
{
public:
int32 TestOrder; // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEnvTestPurpose TestPurpose; // 0x0034(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_35[0x3]; // 0x0035(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
class FString TestComment; // 0x0038(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEnvTestFilterOperator MultipleContextFilterOp; // 0x0048(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEnvTestScoreOperator MultipleContextScoreOp; // 0x0049(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEnvTestFilterType FilterType; // 0x004A(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_4B[0x5]; // 0x004B(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
struct FAIDataProviderBoolValue BoolValue; // 0x0050(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue FloatValueMin; // 0x0088(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue FloatValueMax; // 0x00C0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
uint8 Pad_F8[0x1]; // 0x00F8(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
EEnvTestScoreEquation ScoringEquation; // 0x00F9(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEnvQueryTestClamping ClampMinType; // 0x00FA(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEnvQueryTestClamping ClampMaxType; // 0x00FB(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEQSNormalizationType NormalizationType; // 0x00FC(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_FD[0x3]; // 0x00FD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
struct FAIDataProviderFloatValue ScoreClampMin; // 0x0100(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ScoreClampMax; // 0x0138(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ScoringFactor; // 0x0170(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ReferenceValue; // 0x01A8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
bool bDefineReferenceValue; // 0x01E0(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_1E1[0xF]; // 0x01E1(0x000F)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bWorkOnFloatValues : 1; // 0x01F0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
uint8 Pad_1F1[0x7]; // 0x01F1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest">();
}
static class UEnvQueryTest* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest>();
}
};
static_assert(alignof(UEnvQueryTest) == 0x000008, "Wrong alignment on UEnvQueryTest");
static_assert(sizeof(UEnvQueryTest) == 0x0001F8, "Wrong size on UEnvQueryTest");
static_assert(offsetof(UEnvQueryTest, TestOrder) == 0x000030, "Member 'UEnvQueryTest::TestOrder' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, TestPurpose) == 0x000034, "Member 'UEnvQueryTest::TestPurpose' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, TestComment) == 0x000038, "Member 'UEnvQueryTest::TestComment' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, MultipleContextFilterOp) == 0x000048, "Member 'UEnvQueryTest::MultipleContextFilterOp' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, MultipleContextScoreOp) == 0x000049, "Member 'UEnvQueryTest::MultipleContextScoreOp' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, FilterType) == 0x00004A, "Member 'UEnvQueryTest::FilterType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, BoolValue) == 0x000050, "Member 'UEnvQueryTest::BoolValue' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, FloatValueMin) == 0x000088, "Member 'UEnvQueryTest::FloatValueMin' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, FloatValueMax) == 0x0000C0, "Member 'UEnvQueryTest::FloatValueMax' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoringEquation) == 0x0000F9, "Member 'UEnvQueryTest::ScoringEquation' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ClampMinType) == 0x0000FA, "Member 'UEnvQueryTest::ClampMinType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ClampMaxType) == 0x0000FB, "Member 'UEnvQueryTest::ClampMaxType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, NormalizationType) == 0x0000FC, "Member 'UEnvQueryTest::NormalizationType' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoreClampMin) == 0x000100, "Member 'UEnvQueryTest::ScoreClampMin' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoreClampMax) == 0x000138, "Member 'UEnvQueryTest::ScoreClampMax' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ScoringFactor) == 0x000170, "Member 'UEnvQueryTest::ScoringFactor' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, ReferenceValue) == 0x0001A8, "Member 'UEnvQueryTest::ReferenceValue' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest, bDefineReferenceValue) == 0x0001E0, "Member 'UEnvQueryTest::bDefineReferenceValue' has a wrong offset!");
// Class AIModule.AISystem
// 0x00D8 (0x0130 - 0x0058)
class UAISystem : public UAISystemBase
{
public:
struct FSoftClassPath PerceptionSystemClassName; // 0x0058(0x0018)(Edit, ZeroConstructor, Config, GlobalConfig, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
struct FSoftClassPath HotSpotManagerClassName; // 0x0070(0x0018)(Edit, ZeroConstructor, Config, GlobalConfig, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float AcceptanceRadius; // 0x0088(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PathfollowingRegularPathPointAcceptanceRadius; // 0x008C(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PathfollowingNavLinkAcceptanceRadius; // 0x0090(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bFinishMoveOnGoalOverlap; // 0x0094(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAcceptPartialPaths; // 0x0095(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAllowStrafing; // 0x0096(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bEnableBTAITasks; // 0x0097(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAllowControllersAsEQSQuerier; // 0x0098(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bEnableDebuggerPlugin; // 0x0099(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bForgetStaleActors; // 0x009A(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAddBlackboardSelfKey; // 0x009B(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
ECollisionChannel DefaultSightCollisionChannel; // 0x009C(0x0001)(Edit, ZeroConstructor, Config, DisableEditOnInstance, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_9D[0x3]; // 0x009D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
class UBehaviorTreeManager* BehaviorTreeManager; // 0x00A0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UEnvQueryManager* EnvironmentQueryManager; // 0x00A8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UAIPerceptionSystem* PerceptionSystem; // 0x00B0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<class UAIAsyncTaskBlueprintProxy*> AllProxyObjects; // 0x00B8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
class UAIHotSpotManager* HotSpotManager; // 0x00C8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UNavLocalGridManager* NavLocalGrids; // 0x00D0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_D8[0x58]; // 0x00D8(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void AIIgnorePlayers();
void AILoggingVerbose();
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISystem">();
}
static class UAISystem* GetDefaultObj()
{
return GetDefaultObjImpl<UAISystem>();
}
};
static_assert(alignof(UAISystem) == 0x000008, "Wrong alignment on UAISystem");
static_assert(sizeof(UAISystem) == 0x000130, "Wrong size on UAISystem");
static_assert(offsetof(UAISystem, PerceptionSystemClassName) == 0x000058, "Member 'UAISystem::PerceptionSystemClassName' has a wrong offset!");
static_assert(offsetof(UAISystem, HotSpotManagerClassName) == 0x000070, "Member 'UAISystem::HotSpotManagerClassName' has a wrong offset!");
static_assert(offsetof(UAISystem, AcceptanceRadius) == 0x000088, "Member 'UAISystem::AcceptanceRadius' has a wrong offset!");
static_assert(offsetof(UAISystem, PathfollowingRegularPathPointAcceptanceRadius) == 0x00008C, "Member 'UAISystem::PathfollowingRegularPathPointAcceptanceRadius' has a wrong offset!");
static_assert(offsetof(UAISystem, PathfollowingNavLinkAcceptanceRadius) == 0x000090, "Member 'UAISystem::PathfollowingNavLinkAcceptanceRadius' has a wrong offset!");
static_assert(offsetof(UAISystem, bFinishMoveOnGoalOverlap) == 0x000094, "Member 'UAISystem::bFinishMoveOnGoalOverlap' has a wrong offset!");
static_assert(offsetof(UAISystem, bAcceptPartialPaths) == 0x000095, "Member 'UAISystem::bAcceptPartialPaths' has a wrong offset!");
static_assert(offsetof(UAISystem, bAllowStrafing) == 0x000096, "Member 'UAISystem::bAllowStrafing' has a wrong offset!");
static_assert(offsetof(UAISystem, bEnableBTAITasks) == 0x000097, "Member 'UAISystem::bEnableBTAITasks' has a wrong offset!");
static_assert(offsetof(UAISystem, bAllowControllersAsEQSQuerier) == 0x000098, "Member 'UAISystem::bAllowControllersAsEQSQuerier' has a wrong offset!");
static_assert(offsetof(UAISystem, bEnableDebuggerPlugin) == 0x000099, "Member 'UAISystem::bEnableDebuggerPlugin' has a wrong offset!");
static_assert(offsetof(UAISystem, bForgetStaleActors) == 0x00009A, "Member 'UAISystem::bForgetStaleActors' has a wrong offset!");
static_assert(offsetof(UAISystem, bAddBlackboardSelfKey) == 0x00009B, "Member 'UAISystem::bAddBlackboardSelfKey' has a wrong offset!");
static_assert(offsetof(UAISystem, DefaultSightCollisionChannel) == 0x00009C, "Member 'UAISystem::DefaultSightCollisionChannel' has a wrong offset!");
static_assert(offsetof(UAISystem, BehaviorTreeManager) == 0x0000A0, "Member 'UAISystem::BehaviorTreeManager' has a wrong offset!");
static_assert(offsetof(UAISystem, EnvironmentQueryManager) == 0x0000A8, "Member 'UAISystem::EnvironmentQueryManager' has a wrong offset!");
static_assert(offsetof(UAISystem, PerceptionSystem) == 0x0000B0, "Member 'UAISystem::PerceptionSystem' has a wrong offset!");
static_assert(offsetof(UAISystem, AllProxyObjects) == 0x0000B8, "Member 'UAISystem::AllProxyObjects' has a wrong offset!");
static_assert(offsetof(UAISystem, HotSpotManager) == 0x0000C8, "Member 'UAISystem::HotSpotManager' has a wrong offset!");
static_assert(offsetof(UAISystem, NavLocalGrids) == 0x0000D0, "Member 'UAISystem::NavLocalGrids' has a wrong offset!");
// Class AIModule.AISenseConfig
// 0x0020 (0x0048 - 0x0028)
class UAISenseConfig : public UObject
{
public:
struct FColor DebugColor; // 0x0028(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float MaxAge; // 0x002C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 bStartsEnabled : 1; // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_31[0x17]; // 0x0031(0x0017)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig">();
}
static class UAISenseConfig* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig>();
}
};
static_assert(alignof(UAISenseConfig) == 0x000008, "Wrong alignment on UAISenseConfig");
static_assert(sizeof(UAISenseConfig) == 0x000048, "Wrong size on UAISenseConfig");
static_assert(offsetof(UAISenseConfig, DebugColor) == 0x000028, "Member 'UAISenseConfig::DebugColor' has a wrong offset!");
static_assert(offsetof(UAISenseConfig, MaxAge) == 0x00002C, "Member 'UAISenseConfig::MaxAge' has a wrong offset!");
// Class AIModule.AISenseConfig_Touch
// 0x0000 (0x0048 - 0x0048)
class UAISenseConfig_Touch final : public UAISenseConfig
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig_Touch">();
}
static class UAISenseConfig_Touch* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig_Touch>();
}
};
static_assert(alignof(UAISenseConfig_Touch) == 0x000008, "Wrong alignment on UAISenseConfig_Touch");
static_assert(sizeof(UAISenseConfig_Touch) == 0x000048, "Wrong size on UAISenseConfig_Touch");
// Class AIModule.EnvQueryContext
// 0x0000 (0x0028 - 0x0028)
class UEnvQueryContext : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryContext">();
}
static class UEnvQueryContext* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryContext>();
}
};
static_assert(alignof(UEnvQueryContext) == 0x000008, "Wrong alignment on UEnvQueryContext");
static_assert(sizeof(UEnvQueryContext) == 0x000028, "Wrong size on UEnvQueryContext");
// Class AIModule.PathFollowingComponent
// 0x01A0 (0x0250 - 0x00B0)
class UPathFollowingComponent : public UActorComponent
{
public:
uint8 Pad_B0[0x38]; // 0x00B0(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
class UNavMovementComponent* MovementComp; // 0x00E8(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_F0[0x8]; // 0x00F0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
class ANavigationData* MyNavData; // 0x00F8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_100[0x150]; // 0x0100(0x0150)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void OnActorBump(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit);
void OnNavDataRegistered(class ANavigationData* NavData);
EPathFollowingAction GetPathActionType() const;
struct FVector GetPathDestination() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PathFollowingComponent">();
}
static class UPathFollowingComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UPathFollowingComponent>();
}
};
static_assert(alignof(UPathFollowingComponent) == 0x000008, "Wrong alignment on UPathFollowingComponent");
static_assert(sizeof(UPathFollowingComponent) == 0x000250, "Wrong size on UPathFollowingComponent");
static_assert(offsetof(UPathFollowingComponent, MovementComp) == 0x0000E8, "Member 'UPathFollowingComponent::MovementComp' has a wrong offset!");
static_assert(offsetof(UPathFollowingComponent, MyNavData) == 0x0000F8, "Member 'UPathFollowingComponent::MyNavData' has a wrong offset!");
// Class AIModule.CrowdFollowingComponent
// 0x0048 (0x0298 - 0x0250)
class UCrowdFollowingComponent final : public UPathFollowingComponent
{
public:
uint8 Pad_250[0x18]; // 0x0250(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
struct FVector CrowdAgentMoveDirection; // 0x0268(0x000C)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_274[0x24]; // 0x0274(0x0024)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void SuspendCrowdSteering(bool bSuspend);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"CrowdFollowingComponent">();
}
static class UCrowdFollowingComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UCrowdFollowingComponent>();
}
};
static_assert(alignof(UCrowdFollowingComponent) == 0x000008, "Wrong alignment on UCrowdFollowingComponent");
static_assert(sizeof(UCrowdFollowingComponent) == 0x000298, "Wrong size on UCrowdFollowingComponent");
static_assert(offsetof(UCrowdFollowingComponent, CrowdAgentMoveDirection) == 0x000268, "Member 'UCrowdFollowingComponent::CrowdAgentMoveDirection' has a wrong offset!");
// Class AIModule.BehaviorTreeComponent
// 0x0190 (0x0298 - 0x0108)
class UBehaviorTreeComponent : public UBrainComponent
{
public:
uint8 Pad_108[0x20]; // 0x0108(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
TArray<class UBTNode*> NodeInstances; // 0x0128(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
uint8 Pad_138[0x140]; // 0x0138(0x0140)(Fixing Size After Last Property [ Dumper-7 ])
class UBehaviorTree* DefaultBehaviorTreeAsset; // 0x0278(0x0008)(Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_280[0x18]; // 0x0280(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void AddCooldownTagDuration(const struct FGameplayTag& CooldownTag, float CooldownDuration, bool bAddToExistingDuration);
void SetDynamicSubtree(const struct FGameplayTag& InjectTag, class UBehaviorTree* BehaviorAsset);
float GetTagCooldownEndTime(const struct FGameplayTag& CooldownTag) const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BehaviorTreeComponent">();
}
static class UBehaviorTreeComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UBehaviorTreeComponent>();
}
};
static_assert(alignof(UBehaviorTreeComponent) == 0x000008, "Wrong alignment on UBehaviorTreeComponent");
static_assert(sizeof(UBehaviorTreeComponent) == 0x000298, "Wrong size on UBehaviorTreeComponent");
static_assert(offsetof(UBehaviorTreeComponent, NodeInstances) == 0x000128, "Member 'UBehaviorTreeComponent::NodeInstances' has a wrong offset!");
static_assert(offsetof(UBehaviorTreeComponent, DefaultBehaviorTreeAsset) == 0x000278, "Member 'UBehaviorTreeComponent::DefaultBehaviorTreeAsset' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_ProjectedPoints
// 0x0030 (0x0080 - 0x0050)
class UEnvQueryGenerator_ProjectedPoints : public UEnvQueryGenerator
{
public:
struct FEnvTraceData ProjectionData; // 0x0050(0x0030)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_ProjectedPoints">();
}
static class UEnvQueryGenerator_ProjectedPoints* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_ProjectedPoints>();
}
};
static_assert(alignof(UEnvQueryGenerator_ProjectedPoints) == 0x000008, "Wrong alignment on UEnvQueryGenerator_ProjectedPoints");
static_assert(sizeof(UEnvQueryGenerator_ProjectedPoints) == 0x000080, "Wrong size on UEnvQueryGenerator_ProjectedPoints");
static_assert(offsetof(UEnvQueryGenerator_ProjectedPoints, ProjectionData) == 0x000050, "Member 'UEnvQueryGenerator_ProjectedPoints::ProjectionData' has a wrong offset!");
// Class AIModule.BlackboardAssetProvider
// 0x0000 (0x0000 - 0x0000)
class IBlackboardAssetProvider final
{
public:
class UBlackboardData* GetBlackboardAsset() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardAssetProvider">();
}
static class IBlackboardAssetProvider* GetDefaultObj()
{
return GetDefaultObjImpl<IBlackboardAssetProvider>();
}
class UObject* AsUObject()
{
return reinterpret_cast<UObject*>(this);
}
const class UObject* AsUObject() const
{
return reinterpret_cast<const UObject*>(this);
}
};
static_assert(alignof(IBlackboardAssetProvider) == 0x000001, "Wrong alignment on IBlackboardAssetProvider");
static_assert(sizeof(IBlackboardAssetProvider) == 0x000001, "Wrong size on IBlackboardAssetProvider");
// Class AIModule.EnvQueryGenerator_Donut
// 0x0150 (0x01D0 - 0x0080)
class UEnvQueryGenerator_Donut : public UEnvQueryGenerator_ProjectedPoints
{
public:
struct FAIDataProviderFloatValue InnerRadius; // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue OuterRadius; // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderIntValue NumberOfRings; // 0x00F0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderIntValue PointsPerRing; // 0x0128(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FEnvDirection ArcDirection; // 0x0160(0x0020)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ArcAngle; // 0x0180(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
bool bUseSpiralPattern; // 0x01B8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_1B9[0x7]; // 0x01B9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UEnvQueryContext> Center; // 0x01C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 bDefineArc : 1; // 0x01C8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_1C9[0x7]; // 0x01C9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_Donut">();
}
static class UEnvQueryGenerator_Donut* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_Donut>();
}
};
static_assert(alignof(UEnvQueryGenerator_Donut) == 0x000008, "Wrong alignment on UEnvQueryGenerator_Donut");
static_assert(sizeof(UEnvQueryGenerator_Donut) == 0x0001D0, "Wrong size on UEnvQueryGenerator_Donut");
static_assert(offsetof(UEnvQueryGenerator_Donut, InnerRadius) == 0x000080, "Member 'UEnvQueryGenerator_Donut::InnerRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, OuterRadius) == 0x0000B8, "Member 'UEnvQueryGenerator_Donut::OuterRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, NumberOfRings) == 0x0000F0, "Member 'UEnvQueryGenerator_Donut::NumberOfRings' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, PointsPerRing) == 0x000128, "Member 'UEnvQueryGenerator_Donut::PointsPerRing' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, ArcDirection) == 0x000160, "Member 'UEnvQueryGenerator_Donut::ArcDirection' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, ArcAngle) == 0x000180, "Member 'UEnvQueryGenerator_Donut::ArcAngle' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, bUseSpiralPattern) == 0x0001B8, "Member 'UEnvQueryGenerator_Donut::bUseSpiralPattern' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Donut, Center) == 0x0001C0, "Member 'UEnvQueryGenerator_Donut::Center' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_Cone
// 0x00F0 (0x0170 - 0x0080)
class UEnvQueryGenerator_Cone final : public UEnvQueryGenerator_ProjectedPoints
{
public:
struct FAIDataProviderFloatValue AlignedPointsDistance; // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
struct FAIDataProviderFloatValue ConeDegrees; // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
struct FAIDataProviderFloatValue AngleStep; // 0x00F0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
struct FAIDataProviderFloatValue Range; // 0x0128(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
TSubclassOf<class UEnvQueryContext> CenterActor; // 0x0160(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 bIncludeContextLocation : 1; // 0x0168(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_169[0x7]; // 0x0169(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_Cone">();
}
static class UEnvQueryGenerator_Cone* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_Cone>();
}
};
static_assert(alignof(UEnvQueryGenerator_Cone) == 0x000008, "Wrong alignment on UEnvQueryGenerator_Cone");
static_assert(sizeof(UEnvQueryGenerator_Cone) == 0x000170, "Wrong size on UEnvQueryGenerator_Cone");
static_assert(offsetof(UEnvQueryGenerator_Cone, AlignedPointsDistance) == 0x000080, "Member 'UEnvQueryGenerator_Cone::AlignedPointsDistance' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, ConeDegrees) == 0x0000B8, "Member 'UEnvQueryGenerator_Cone::ConeDegrees' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, AngleStep) == 0x0000F0, "Member 'UEnvQueryGenerator_Cone::AngleStep' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, Range) == 0x000128, "Member 'UEnvQueryGenerator_Cone::Range' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Cone, CenterActor) == 0x000160, "Member 'UEnvQueryGenerator_Cone::CenterActor' has a wrong offset!");
// Class AIModule.AIDataProvider
// 0x0000 (0x0028 - 0x0028)
class UAIDataProvider : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIDataProvider">();
}
static class UAIDataProvider* GetDefaultObj()
{
return GetDefaultObjImpl<UAIDataProvider>();
}
};
static_assert(alignof(UAIDataProvider) == 0x000008, "Wrong alignment on UAIDataProvider");
static_assert(sizeof(UAIDataProvider) == 0x000028, "Wrong size on UAIDataProvider");
// Class AIModule.AIDataProvider_QueryParams
// 0x0018 (0x0040 - 0x0028)
class UAIDataProvider_QueryParams : public UAIDataProvider
{
public:
class FName ParamName; // 0x0028(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float FloatValue; // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int32 IntValue; // 0x0034(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool BoolValue; // 0x0038(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_39[0x7]; // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIDataProvider_QueryParams">();
}
static class UAIDataProvider_QueryParams* GetDefaultObj()
{
return GetDefaultObjImpl<UAIDataProvider_QueryParams>();
}
};
static_assert(alignof(UAIDataProvider_QueryParams) == 0x000008, "Wrong alignment on UAIDataProvider_QueryParams");
static_assert(sizeof(UAIDataProvider_QueryParams) == 0x000040, "Wrong size on UAIDataProvider_QueryParams");
static_assert(offsetof(UAIDataProvider_QueryParams, ParamName) == 0x000028, "Member 'UAIDataProvider_QueryParams::ParamName' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_QueryParams, FloatValue) == 0x000030, "Member 'UAIDataProvider_QueryParams::FloatValue' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_QueryParams, IntValue) == 0x000034, "Member 'UAIDataProvider_QueryParams::IntValue' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_QueryParams, BoolValue) == 0x000038, "Member 'UAIDataProvider_QueryParams::BoolValue' has a wrong offset!");
// Class AIModule.BTNode
// 0x0030 (0x0058 - 0x0028)
class UBTNode : public UObject
{
public:
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
class FString NodeName; // 0x0030(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UBehaviorTree* TreeAsset; // 0x0040(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UBTCompositeNode* ParentNode; // 0x0048(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
uint8 Pad_50[0x8]; // 0x0050(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTNode">();
}
static class UBTNode* GetDefaultObj()
{
return GetDefaultObjImpl<UBTNode>();
}
};
static_assert(alignof(UBTNode) == 0x000008, "Wrong alignment on UBTNode");
static_assert(sizeof(UBTNode) == 0x000058, "Wrong size on UBTNode");
static_assert(offsetof(UBTNode, NodeName) == 0x000030, "Member 'UBTNode::NodeName' has a wrong offset!");
static_assert(offsetof(UBTNode, TreeAsset) == 0x000040, "Member 'UBTNode::TreeAsset' has a wrong offset!");
static_assert(offsetof(UBTNode, ParentNode) == 0x000048, "Member 'UBTNode::ParentNode' has a wrong offset!");
// Class AIModule.AIAsyncTaskBlueprintProxy
// 0x0040 (0x0068 - 0x0028)
class UAIAsyncTaskBlueprintProxy final : public UObject
{
public:
TMulticastInlineDelegate<void(EPathFollowingResult MovementResult)> OnSuccess; // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
TMulticastInlineDelegate<void(EPathFollowingResult MovementResult)> OnFail; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
uint8 Pad_48[0x20]; // 0x0048(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void OnMoveCompleted(const struct FAIRequestID& RequestID, EPathFollowingResult MovementResult);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIAsyncTaskBlueprintProxy">();
}
static class UAIAsyncTaskBlueprintProxy* GetDefaultObj()
{
return GetDefaultObjImpl<UAIAsyncTaskBlueprintProxy>();
}
};
static_assert(alignof(UAIAsyncTaskBlueprintProxy) == 0x000008, "Wrong alignment on UAIAsyncTaskBlueprintProxy");
static_assert(sizeof(UAIAsyncTaskBlueprintProxy) == 0x000068, "Wrong size on UAIAsyncTaskBlueprintProxy");
static_assert(offsetof(UAIAsyncTaskBlueprintProxy, OnSuccess) == 0x000028, "Member 'UAIAsyncTaskBlueprintProxy::OnSuccess' has a wrong offset!");
static_assert(offsetof(UAIAsyncTaskBlueprintProxy, OnFail) == 0x000038, "Member 'UAIAsyncTaskBlueprintProxy::OnFail' has a wrong offset!");
// Class AIModule.BTAuxiliaryNode
// 0x0008 (0x0060 - 0x0058)
class UBTAuxiliaryNode : public UBTNode
{
public:
uint8 Pad_58[0x8]; // 0x0058(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTAuxiliaryNode">();
}
static class UBTAuxiliaryNode* GetDefaultObj()
{
return GetDefaultObjImpl<UBTAuxiliaryNode>();
}
};
static_assert(alignof(UBTAuxiliaryNode) == 0x000008, "Wrong alignment on UBTAuxiliaryNode");
static_assert(sizeof(UBTAuxiliaryNode) == 0x000060, "Wrong size on UBTAuxiliaryNode");
// Class AIModule.BTDecorator
// 0x0008 (0x0068 - 0x0060)
class UBTDecorator : public UBTAuxiliaryNode
{
public:
uint8 BitPad_60_0 : 7; // 0x0060(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
uint8 bInverseCondition : 1; // 0x0060(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
uint8 Pad_61[0x3]; // 0x0061(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
EBTFlowAbortMode FlowAbortMode; // 0x0064(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_65[0x3]; // 0x0065(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator">();
}
static class UBTDecorator* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator>();
}
};
static_assert(alignof(UBTDecorator) == 0x000008, "Wrong alignment on UBTDecorator");
static_assert(sizeof(UBTDecorator) == 0x000068, "Wrong size on UBTDecorator");
static_assert(offsetof(UBTDecorator, FlowAbortMode) == 0x000064, "Member 'UBTDecorator::FlowAbortMode' has a wrong offset!");
// Class AIModule.BTDecorator_CompareBBEntries
// 0x0058 (0x00C0 - 0x0068)
class UBTDecorator_CompareBBEntries final : public UBTDecorator
{
public:
EBlackBoardEntryComparison Operator; // 0x0068(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_69[0x7]; // 0x0069(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
struct FBlackboardKeySelector BlackboardKeyA; // 0x0070(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
struct FBlackboardKeySelector BlackboardKeyB; // 0x0098(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_CompareBBEntries">();
}
static class UBTDecorator_CompareBBEntries* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_CompareBBEntries>();
}
};
static_assert(alignof(UBTDecorator_CompareBBEntries) == 0x000008, "Wrong alignment on UBTDecorator_CompareBBEntries");
static_assert(sizeof(UBTDecorator_CompareBBEntries) == 0x0000C0, "Wrong size on UBTDecorator_CompareBBEntries");
static_assert(offsetof(UBTDecorator_CompareBBEntries, Operator) == 0x000068, "Member 'UBTDecorator_CompareBBEntries::Operator' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CompareBBEntries, BlackboardKeyA) == 0x000070, "Member 'UBTDecorator_CompareBBEntries::BlackboardKeyA' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CompareBBEntries, BlackboardKeyB) == 0x000098, "Member 'UBTDecorator_CompareBBEntries::BlackboardKeyB' has a wrong offset!");
// Class AIModule.BTTaskNode
// 0x0018 (0x0070 - 0x0058)
class UBTTaskNode : public UBTNode
{
public:
TArray<class UBTService*> Services; // 0x0058(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
uint8 bIgnoreRestartSelf : 1; // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_69[0x7]; // 0x0069(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTaskNode">();
}
static class UBTTaskNode* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTaskNode>();
}
};
static_assert(alignof(UBTTaskNode) == 0x000008, "Wrong alignment on UBTTaskNode");
static_assert(sizeof(UBTTaskNode) == 0x000070, "Wrong size on UBTTaskNode");
static_assert(offsetof(UBTTaskNode, Services) == 0x000058, "Member 'UBTTaskNode::Services' has a wrong offset!");
// Class AIModule.BTTask_Wait
// 0x0008 (0x0078 - 0x0070)
class UBTTask_Wait : public UBTTaskNode
{
public:
float WaitTime; // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float RandomDeviation; // 0x0074(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_Wait">();
}
static class UBTTask_Wait* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_Wait>();
}
};
static_assert(alignof(UBTTask_Wait) == 0x000008, "Wrong alignment on UBTTask_Wait");
static_assert(sizeof(UBTTask_Wait) == 0x000078, "Wrong size on UBTTask_Wait");
static_assert(offsetof(UBTTask_Wait, WaitTime) == 0x000070, "Member 'UBTTask_Wait::WaitTime' has a wrong offset!");
static_assert(offsetof(UBTTask_Wait, RandomDeviation) == 0x000074, "Member 'UBTTask_Wait::RandomDeviation' has a wrong offset!");
// Class AIModule.BTTask_WaitBlackboardTime
// 0x0028 (0x00A0 - 0x0078)
class UBTTask_WaitBlackboardTime final : public UBTTask_Wait
{
public:
struct FBlackboardKeySelector BlackboardKey; // 0x0078(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_WaitBlackboardTime">();
}
static class UBTTask_WaitBlackboardTime* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_WaitBlackboardTime>();
}
};
static_assert(alignof(UBTTask_WaitBlackboardTime) == 0x000008, "Wrong alignment on UBTTask_WaitBlackboardTime");
static_assert(sizeof(UBTTask_WaitBlackboardTime) == 0x0000A0, "Wrong size on UBTTask_WaitBlackboardTime");
static_assert(offsetof(UBTTask_WaitBlackboardTime, BlackboardKey) == 0x000078, "Member 'UBTTask_WaitBlackboardTime::BlackboardKey' has a wrong offset!");
// Class AIModule.BTCompositeNode
// 0x0038 (0x0090 - 0x0058)
class UBTCompositeNode : public UBTNode
{
public:
TArray<struct FBTCompositeChild> Children; // 0x0058(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
TArray<class UBTService*> Services; // 0x0068(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
uint8 Pad_78[0x10]; // 0x0078(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bApplyDecoratorScope : 1; // 0x0088(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_89[0x7]; // 0x0089(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTCompositeNode">();
}
static class UBTCompositeNode* GetDefaultObj()
{
return GetDefaultObjImpl<UBTCompositeNode>();
}
};
static_assert(alignof(UBTCompositeNode) == 0x000008, "Wrong alignment on UBTCompositeNode");
static_assert(sizeof(UBTCompositeNode) == 0x000090, "Wrong size on UBTCompositeNode");
static_assert(offsetof(UBTCompositeNode, Children) == 0x000058, "Member 'UBTCompositeNode::Children' has a wrong offset!");
static_assert(offsetof(UBTCompositeNode, Services) == 0x000068, "Member 'UBTCompositeNode::Services' has a wrong offset!");
// Class AIModule.AISense
// 0x0058 (0x0080 - 0x0028)
class UAISense : public UObject
{
public:
float DefaultExpirationAge; // 0x0028(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
EAISenseNotifyType NotifyType; // 0x002C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_2D[0x3]; // 0x002D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bWantsNewPawnNotification : 1; // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bAutoRegisterAllPawnsAsSources : 1; // 0x0030(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_31[0x7]; // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
class UAIPerceptionSystem* PerceptionSystemInstance; // 0x0038(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
uint8 Pad_40[0x40]; // 0x0040(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense">();
}
static class UAISense* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense>();
}
};
static_assert(alignof(UAISense) == 0x000008, "Wrong alignment on UAISense");
static_assert(sizeof(UAISense) == 0x000080, "Wrong size on UAISense");
static_assert(offsetof(UAISense, DefaultExpirationAge) == 0x000028, "Member 'UAISense::DefaultExpirationAge' has a wrong offset!");
static_assert(offsetof(UAISense, NotifyType) == 0x00002C, "Member 'UAISense::NotifyType' has a wrong offset!");
static_assert(offsetof(UAISense, PerceptionSystemInstance) == 0x000038, "Member 'UAISense::PerceptionSystemInstance' has a wrong offset!");
// Class AIModule.AISense_Team
// 0x0010 (0x0090 - 0x0080)
class UAISense_Team final : public UAISense
{
public:
TArray<struct FAITeamStimulusEvent> RegisteredEvents; // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense_Team">();
}
static class UAISense_Team* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense_Team>();
}
};
static_assert(alignof(UAISense_Team) == 0x000008, "Wrong alignment on UAISense_Team");
static_assert(sizeof(UAISense_Team) == 0x000090, "Wrong size on UAISense_Team");
static_assert(offsetof(UAISense_Team, RegisteredEvents) == 0x000080, "Member 'UAISense_Team::RegisteredEvents' has a wrong offset!");
// Class AIModule.BTDecorator_BlackboardBase
// 0x0028 (0x0090 - 0x0068)
class UBTDecorator_BlackboardBase : public UBTDecorator
{
public:
struct FBlackboardKeySelector BlackboardKey; // 0x0068(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_BlackboardBase">();
}
static class UBTDecorator_BlackboardBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_BlackboardBase>();
}
};
static_assert(alignof(UBTDecorator_BlackboardBase) == 0x000008, "Wrong alignment on UBTDecorator_BlackboardBase");
static_assert(sizeof(UBTDecorator_BlackboardBase) == 0x000090, "Wrong size on UBTDecorator_BlackboardBase");
static_assert(offsetof(UBTDecorator_BlackboardBase, BlackboardKey) == 0x000068, "Member 'UBTDecorator_BlackboardBase::BlackboardKey' has a wrong offset!");
// Class AIModule.AISenseConfig_Damage
// 0x0008 (0x0050 - 0x0048)
class UAISenseConfig_Damage final : public UAISenseConfig
{
public:
TSubclassOf<class UAISense_Damage> Implementation; // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig_Damage">();
}
static class UAISenseConfig_Damage* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig_Damage>();
}
};
static_assert(alignof(UAISenseConfig_Damage) == 0x000008, "Wrong alignment on UAISenseConfig_Damage");
static_assert(sizeof(UAISenseConfig_Damage) == 0x000050, "Wrong size on UAISenseConfig_Damage");
static_assert(offsetof(UAISenseConfig_Damage, Implementation) == 0x000048, "Member 'UAISenseConfig_Damage::Implementation' has a wrong offset!");
// Class AIModule.EnvQueryTest_Pathfinding
// 0x0088 (0x0280 - 0x01F8)
class UEnvQueryTest_Pathfinding : public UEnvQueryTest
{
public:
EEnvTestPathfinding TestMode; // 0x01F8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_1F9[0x7]; // 0x01F9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UEnvQueryContext> Context; // 0x0200(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FAIDataProviderBoolValue PathFromContext; // 0x0208(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderBoolValue SkipUnreachable; // 0x0240(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
TSubclassOf<class UNavigationQueryFilter> FilterClass; // 0x0278(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Pathfinding">();
}
static class UEnvQueryTest_Pathfinding* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Pathfinding>();
}
};
static_assert(alignof(UEnvQueryTest_Pathfinding) == 0x000008, "Wrong alignment on UEnvQueryTest_Pathfinding");
static_assert(sizeof(UEnvQueryTest_Pathfinding) == 0x000280, "Wrong size on UEnvQueryTest_Pathfinding");
static_assert(offsetof(UEnvQueryTest_Pathfinding, TestMode) == 0x0001F8, "Member 'UEnvQueryTest_Pathfinding::TestMode' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, Context) == 0x000200, "Member 'UEnvQueryTest_Pathfinding::Context' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, PathFromContext) == 0x000208, "Member 'UEnvQueryTest_Pathfinding::PathFromContext' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, SkipUnreachable) == 0x000240, "Member 'UEnvQueryTest_Pathfinding::SkipUnreachable' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Pathfinding, FilterClass) == 0x000278, "Member 'UEnvQueryTest_Pathfinding::FilterClass' has a wrong offset!");
// Class AIModule.BTDecorator_TimeLimit
// 0x0008 (0x0070 - 0x0068)
class UBTDecorator_TimeLimit : public UBTDecorator
{
public:
float TimeLimit; // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_6C[0x4]; // 0x006C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_TimeLimit">();
}
static class UBTDecorator_TimeLimit* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_TimeLimit>();
}
};
static_assert(alignof(UBTDecorator_TimeLimit) == 0x000008, "Wrong alignment on UBTDecorator_TimeLimit");
static_assert(sizeof(UBTDecorator_TimeLimit) == 0x000070, "Wrong size on UBTDecorator_TimeLimit");
static_assert(offsetof(UBTDecorator_TimeLimit, TimeLimit) == 0x000068, "Member 'UBTDecorator_TimeLimit::TimeLimit' has a wrong offset!");
// Class AIModule.BTService
// 0x0010 (0x0070 - 0x0060)
class UBTService : public UBTAuxiliaryNode
{
public:
float Interval; // 0x0060(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float RandomDeviation; // 0x0064(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 bCallTickOnSearchStart : 1; // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bRestartTimerOnEachActivation : 1; // 0x0068(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_69[0x7]; // 0x0069(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTService">();
}
static class UBTService* GetDefaultObj()
{
return GetDefaultObjImpl<UBTService>();
}
};
static_assert(alignof(UBTService) == 0x000008, "Wrong alignment on UBTService");
static_assert(sizeof(UBTService) == 0x000070, "Wrong size on UBTService");
static_assert(offsetof(UBTService, Interval) == 0x000060, "Member 'UBTService::Interval' has a wrong offset!");
static_assert(offsetof(UBTService, RandomDeviation) == 0x000064, "Member 'UBTService::RandomDeviation' has a wrong offset!");
// Class AIModule.AITask
// 0x0008 (0x0070 - 0x0068)
class UAITask : public UGameplayTask
{
public:
class AAIController* OwnerController; // 0x0068(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AITask">();
}
static class UAITask* GetDefaultObj()
{
return GetDefaultObjImpl<UAITask>();
}
};
static_assert(alignof(UAITask) == 0x000008, "Wrong alignment on UAITask");
static_assert(sizeof(UAITask) == 0x000070, "Wrong size on UAITask");
static_assert(offsetof(UAITask, OwnerController) == 0x000068, "Member 'UAITask::OwnerController' has a wrong offset!");
// Class AIModule.AITask_RunEQS
// 0x0078 (0x00E8 - 0x0070)
class UAITask_RunEQS final : public UAITask
{
public:
uint8 Pad_70[0x78]; // 0x0070(0x0078)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UAITask_RunEQS* RunEQS(class AAIController* Controller, class UEnvQuery* QueryTemplate);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AITask_RunEQS">();
}
static class UAITask_RunEQS* GetDefaultObj()
{
return GetDefaultObjImpl<UAITask_RunEQS>();
}
};
static_assert(alignof(UAITask_RunEQS) == 0x000008, "Wrong alignment on UAITask_RunEQS");
static_assert(sizeof(UAITask_RunEQS) == 0x0000E8, "Wrong size on UAITask_RunEQS");
// Class AIModule.BTTask_GameplayTaskBase
// 0x0008 (0x0078 - 0x0070)
class UBTTask_GameplayTaskBase final : public UBTTaskNode
{
public:
uint8 bWaitForGameplayTask : 1; // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_71[0x7]; // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_GameplayTaskBase">();
}
static class UBTTask_GameplayTaskBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_GameplayTaskBase>();
}
};
static_assert(alignof(UBTTask_GameplayTaskBase) == 0x000008, "Wrong alignment on UBTTask_GameplayTaskBase");
static_assert(sizeof(UBTTask_GameplayTaskBase) == 0x000078, "Wrong size on UBTTask_GameplayTaskBase");
// Class AIModule.BlackboardData
// 0x0020 (0x0050 - 0x0030)
class UBlackboardData final : public UDataAsset
{
public:
class UBlackboardData* Parent; // 0x0030(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FBlackboardEntry> keys; // 0x0038(0x0010)(Edit, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
uint8 bHasSynchronizedKeys : 1; // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
uint8 Pad_49[0x7]; // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardData">();
}
static class UBlackboardData* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardData>();
}
};
static_assert(alignof(UBlackboardData) == 0x000008, "Wrong alignment on UBlackboardData");
static_assert(sizeof(UBlackboardData) == 0x000050, "Wrong size on UBlackboardData");
static_assert(offsetof(UBlackboardData, Parent) == 0x000030, "Member 'UBlackboardData::Parent' has a wrong offset!");
static_assert(offsetof(UBlackboardData, keys) == 0x000038, "Member 'UBlackboardData::keys' has a wrong offset!");
// Class AIModule.BTTask_RunBehaviorDynamic
// 0x0018 (0x0088 - 0x0070)
class UBTTask_RunBehaviorDynamic : public UBTTaskNode
{
public:
struct FGameplayTag InjectionTag; // 0x0070(0x0008)(Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UBehaviorTree* DefaultBehaviorAsset; // 0x0078(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UBehaviorTree* BehaviorAsset; // 0x0080(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_RunBehaviorDynamic">();
}
static class UBTTask_RunBehaviorDynamic* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_RunBehaviorDynamic>();
}
};
static_assert(alignof(UBTTask_RunBehaviorDynamic) == 0x000008, "Wrong alignment on UBTTask_RunBehaviorDynamic");
static_assert(sizeof(UBTTask_RunBehaviorDynamic) == 0x000088, "Wrong size on UBTTask_RunBehaviorDynamic");
static_assert(offsetof(UBTTask_RunBehaviorDynamic, InjectionTag) == 0x000070, "Member 'UBTTask_RunBehaviorDynamic::InjectionTag' has a wrong offset!");
static_assert(offsetof(UBTTask_RunBehaviorDynamic, DefaultBehaviorAsset) == 0x000078, "Member 'UBTTask_RunBehaviorDynamic::DefaultBehaviorAsset' has a wrong offset!");
static_assert(offsetof(UBTTask_RunBehaviorDynamic, BehaviorAsset) == 0x000080, "Member 'UBTTask_RunBehaviorDynamic::BehaviorAsset' has a wrong offset!");
// Class AIModule.AIBlueprintHelperLibrary
// 0x0000 (0x0028 - 0x0028)
class UAIBlueprintHelperLibrary final : public UBlueprintFunctionLibrary
{
public:
static class UAIAsyncTaskBlueprintProxy* CreateMoveToProxyObject(class UObject* WorldContextObject, class APawn* Pawn, const struct FVector& Destination, class AActor* TargetActor, float AcceptanceRadius, bool bStopOnOverlap);
static class AAIController* GetAIController(class AActor* ControlledActor);
static class UBlackboardComponent* GetBlackboard(class AActor* Target);
static class UNavigationPath* GetCurrentPath(class AController* Controller);
static int32 GetCurrentPathIndex(const class AController* Controller);
static const TArray<struct FVector> GetCurrentPathPoints(class AController* Controller);
static int32 GetNextNavLinkIndex(const class AController* Controller);
static bool IsValidAIDirection(const struct FVector& DirectionVector);
static bool IsValidAILocation(const struct FVector& Location);
static bool IsValidAIRotation(const struct FRotator& Rotation);
static void LockAIResourcesWithAnimation(class UAnimInstance* AnimInstance, bool bLockMovement, bool LockAILogic);
static void SendAIMessage(class APawn* Target, class FName Message, class UObject* MessageSource, bool bSuccess);
static void SimpleMoveToActor(class AController* Controller, const class AActor* Goal);
static void SimpleMoveToLocation(class AController* Controller, const struct FVector& Goal);
static class APawn* SpawnAIFromClass(class UObject* WorldContextObject, TSubclassOf<class APawn> PawnClass, class UBehaviorTree* BehaviorTree, const struct FVector& Location, const struct FRotator& Rotation, bool bNoCollisionFail, class AActor* Owner);
static void UnlockAIResourcesWithAnimation(class UAnimInstance* AnimInstance, bool bUnlockMovement, bool UnlockAILogic);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIBlueprintHelperLibrary">();
}
static class UAIBlueprintHelperLibrary* GetDefaultObj()
{
return GetDefaultObjImpl<UAIBlueprintHelperLibrary>();
}
};
static_assert(alignof(UAIBlueprintHelperLibrary) == 0x000008, "Wrong alignment on UAIBlueprintHelperLibrary");
static_assert(sizeof(UAIBlueprintHelperLibrary) == 0x000028, "Wrong size on UAIBlueprintHelperLibrary");
// Class AIModule.AIDataProvider_Random
// 0x0010 (0x0050 - 0x0040)
class UAIDataProvider_Random final : public UAIDataProvider_QueryParams
{
public:
float Min; // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float Max; // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 bInteger : 1; // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_49[0x7]; // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIDataProvider_Random">();
}
static class UAIDataProvider_Random* GetDefaultObj()
{
return GetDefaultObjImpl<UAIDataProvider_Random>();
}
};
static_assert(alignof(UAIDataProvider_Random) == 0x000008, "Wrong alignment on UAIDataProvider_Random");
static_assert(sizeof(UAIDataProvider_Random) == 0x000050, "Wrong size on UAIDataProvider_Random");
static_assert(offsetof(UAIDataProvider_Random, Min) == 0x000040, "Member 'UAIDataProvider_Random::Min' has a wrong offset!");
static_assert(offsetof(UAIDataProvider_Random, Max) == 0x000044, "Member 'UAIDataProvider_Random::Max' has a wrong offset!");
// Class AIModule.BTTask_MakeNoise
// 0x0008 (0x0078 - 0x0070)
class UBTTask_MakeNoise final : public UBTTaskNode
{
public:
float Loudnes; // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_74[0x4]; // 0x0074(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_MakeNoise">();
}
static class UBTTask_MakeNoise* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_MakeNoise>();
}
};
static_assert(alignof(UBTTask_MakeNoise) == 0x000008, "Wrong alignment on UBTTask_MakeNoise");
static_assert(sizeof(UBTTask_MakeNoise) == 0x000078, "Wrong size on UBTTask_MakeNoise");
static_assert(offsetof(UBTTask_MakeNoise, Loudnes) == 0x000070, "Member 'UBTTask_MakeNoise::Loudnes' has a wrong offset!");
// Class AIModule.AIHotSpotManager
// 0x0000 (0x0028 - 0x0028)
class UAIHotSpotManager final : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIHotSpotManager">();
}
static class UAIHotSpotManager* GetDefaultObj()
{
return GetDefaultObjImpl<UAIHotSpotManager>();
}
};
static_assert(alignof(UAIHotSpotManager) == 0x000008, "Wrong alignment on UAIHotSpotManager");
static_assert(sizeof(UAIHotSpotManager) == 0x000028, "Wrong size on UAIHotSpotManager");
// Class AIModule.AIPerceptionComponent
// 0x00E0 (0x0190 - 0x00B0)
class UAIPerceptionComponent final : public UActorComponent
{
public:
TArray<class UAISenseConfig*> SensesConfig; // 0x00B0(0x0010)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
TSubclassOf<class UAISense> DominantSense; // 0x00C0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_C8[0x10]; // 0x00C8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
class AAIController* AIOwner; // 0x00D8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_E0[0x80]; // 0x00E0(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
TMulticastInlineDelegate<void(const TArray<class AActor*>& UpdatedActors)> OnPerceptionUpdated; // 0x0160(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
TMulticastInlineDelegate<void(class AActor* Actor, const struct FAIStimulus& Stimulus)> OnTargetPerceptionUpdated; // 0x0170(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
TMulticastInlineDelegate<void(const struct FActorPerceptionUpdateInfo& UpdateInfo)> OnTargetPerceptionInfoUpdated; // 0x0180(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
public:
void ForgetAll();
bool GetActorsPerception(class AActor* Actor, struct FActorPerceptionBlueprintInfo* Info);
void OnOwnerEndPlay(class AActor* Actor, EEndPlayReason EndPlayReason);
void RequestStimuliListenerUpdate();
void SetSenseEnabled(TSubclassOf<class UAISense> SenseClass, const bool bEnable);
void GetCurrentlyPerceivedActors(TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;
void GetKnownPerceivedActors(TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;
void GetPerceivedActors(TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;
void GetPerceivedHostileActors(TArray<class AActor*>* OutActors) const;
void GetPerceivedHostileActorsBySense(const TSubclassOf<class UAISense> SenseToUse, TArray<class AActor*>* OutActors) const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIPerceptionComponent">();
}
static class UAIPerceptionComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UAIPerceptionComponent>();
}
};
static_assert(alignof(UAIPerceptionComponent) == 0x000008, "Wrong alignment on UAIPerceptionComponent");
static_assert(sizeof(UAIPerceptionComponent) == 0x000190, "Wrong size on UAIPerceptionComponent");
static_assert(offsetof(UAIPerceptionComponent, SensesConfig) == 0x0000B0, "Member 'UAIPerceptionComponent::SensesConfig' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, DominantSense) == 0x0000C0, "Member 'UAIPerceptionComponent::DominantSense' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, AIOwner) == 0x0000D8, "Member 'UAIPerceptionComponent::AIOwner' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, OnPerceptionUpdated) == 0x000160, "Member 'UAIPerceptionComponent::OnPerceptionUpdated' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, OnTargetPerceptionUpdated) == 0x000170, "Member 'UAIPerceptionComponent::OnTargetPerceptionUpdated' has a wrong offset!");
static_assert(offsetof(UAIPerceptionComponent, OnTargetPerceptionInfoUpdated) == 0x000180, "Member 'UAIPerceptionComponent::OnTargetPerceptionInfoUpdated' has a wrong offset!");
// Class AIModule.AISubsystem
// 0x0010 (0x0038 - 0x0028)
class UAISubsystem : public UObject
{
public:
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
class UAISystem* AISystem; // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISubsystem">();
}
static class UAISubsystem* GetDefaultObj()
{
return GetDefaultObjImpl<UAISubsystem>();
}
};
static_assert(alignof(UAISubsystem) == 0x000008, "Wrong alignment on UAISubsystem");
static_assert(sizeof(UAISubsystem) == 0x000038, "Wrong size on UAISubsystem");
static_assert(offsetof(UAISubsystem, AISystem) == 0x000030, "Member 'UAISubsystem::AISystem' has a wrong offset!");
// Class AIModule.EnvQueryManager
// 0x0108 (0x0140 - 0x0038)
class UEnvQueryManager final : public UAISubsystem
{
public:
uint8 Pad_38[0x70]; // 0x0038(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
TArray<struct FEnvQueryInstanceCache> InstanceCache; // 0x00A8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
TArray<class UEnvQueryContext*> LocalContexts; // 0x00B8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
TArray<class UEnvQueryInstanceBlueprintWrapper*> GCShieldedWrappers; // 0x00C8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
uint8 Pad_D8[0x54]; // 0x00D8(0x0054)(Fixing Size After Last Property [ Dumper-7 ])
float MaxAllowedTestingTime; // 0x012C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
bool bTestQueriesUsingBreadth; // 0x0130(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_131[0x3]; // 0x0131(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
int32 QueryCountWarningThreshold; // 0x0134(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
double QueryCountWarningInterval; // 0x0138(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UEnvQueryInstanceBlueprintWrapper* RunEQSQuery(class UObject* WorldContextObject, class UEnvQuery* QueryTemplate, class UObject* Querier, EEnvQueryRunMode RunMode, TSubclassOf<class UEnvQueryInstanceBlueprintWrapper> WrapperClass);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryManager">();
}
static class UEnvQueryManager* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryManager>();
}
};
static_assert(alignof(UEnvQueryManager) == 0x000008, "Wrong alignment on UEnvQueryManager");
static_assert(sizeof(UEnvQueryManager) == 0x000140, "Wrong size on UEnvQueryManager");
static_assert(offsetof(UEnvQueryManager, InstanceCache) == 0x0000A8, "Member 'UEnvQueryManager::InstanceCache' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, LocalContexts) == 0x0000B8, "Member 'UEnvQueryManager::LocalContexts' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, GCShieldedWrappers) == 0x0000C8, "Member 'UEnvQueryManager::GCShieldedWrappers' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, MaxAllowedTestingTime) == 0x00012C, "Member 'UEnvQueryManager::MaxAllowedTestingTime' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, bTestQueriesUsingBreadth) == 0x000130, "Member 'UEnvQueryManager::bTestQueriesUsingBreadth' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, QueryCountWarningThreshold) == 0x000134, "Member 'UEnvQueryManager::QueryCountWarningThreshold' has a wrong offset!");
static_assert(offsetof(UEnvQueryManager, QueryCountWarningInterval) == 0x000138, "Member 'UEnvQueryManager::QueryCountWarningInterval' has a wrong offset!");
// Class AIModule.AIPerceptionListenerInterface
// 0x0000 (0x0000 - 0x0000)
class IAIPerceptionListenerInterface final
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIPerceptionListenerInterface">();
}
static class IAIPerceptionListenerInterface* GetDefaultObj()
{
return GetDefaultObjImpl<IAIPerceptionListenerInterface>();
}
class UObject* AsUObject()
{
return reinterpret_cast<UObject*>(this);
}
const class UObject* AsUObject() const
{
return reinterpret_cast<const UObject*>(this);
}
};
static_assert(alignof(IAIPerceptionListenerInterface) == 0x000001, "Wrong alignment on IAIPerceptionListenerInterface");
static_assert(sizeof(IAIPerceptionListenerInterface) == 0x000001, "Wrong size on IAIPerceptionListenerInterface");
// Class AIModule.AIPerceptionStimuliSourceComponent
// 0x0018 (0x00C8 - 0x00B0)
class UAIPerceptionStimuliSourceComponent final : public UActorComponent
{
public:
uint8 bAutoRegisterAsSource : 1; // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_B1[0x7]; // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
TArray<TSubclassOf<class UAISense>> RegisterAsSourceForSenses; // 0x00B8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
public:
void RegisterForSense(TSubclassOf<class UAISense> SenseClass);
void RegisterWithPerceptionSystem();
void UnregisterFromPerceptionSystem();
void UnregisterFromSense(TSubclassOf<class UAISense> SenseClass);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIPerceptionStimuliSourceComponent">();
}
static class UAIPerceptionStimuliSourceComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UAIPerceptionStimuliSourceComponent>();
}
};
static_assert(alignof(UAIPerceptionStimuliSourceComponent) == 0x000008, "Wrong alignment on UAIPerceptionStimuliSourceComponent");
static_assert(sizeof(UAIPerceptionStimuliSourceComponent) == 0x0000C8, "Wrong size on UAIPerceptionStimuliSourceComponent");
static_assert(offsetof(UAIPerceptionStimuliSourceComponent, RegisterAsSourceForSenses) == 0x0000B8, "Member 'UAIPerceptionStimuliSourceComponent::RegisterAsSourceForSenses' has a wrong offset!");
// Class AIModule.AIPerceptionSystem
// 0x00F8 (0x0130 - 0x0038)
class UAIPerceptionSystem final : public UAISubsystem
{
public:
uint8 Pad_38[0x50]; // 0x0038(0x0050)(Fixing Size After Last Property [ Dumper-7 ])
TArray<class UAISense*> Senses; // 0x0088(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
float PerceptionAgingRate; // 0x0098(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_9C[0x94]; // 0x009C(0x0094)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static TSubclassOf<class UAISense> GetSenseClassForStimulus(class UObject* WorldContextObject, const struct FAIStimulus& Stimulus);
static bool RegisterPerceptionStimuliSource(class UObject* WorldContextObject, TSubclassOf<class UAISense> Sense, class AActor* Target);
static void ReportPerceptionEvent(class UObject* WorldContextObject, class UAISenseEvent* PerceptionEvent);
void OnPerceptionStimuliSourceEndPlay(class AActor* Actor, EEndPlayReason EndPlayReason);
void ReportEvent(class UAISenseEvent* PerceptionEvent);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIPerceptionSystem">();
}
static class UAIPerceptionSystem* GetDefaultObj()
{
return GetDefaultObjImpl<UAIPerceptionSystem>();
}
};
static_assert(alignof(UAIPerceptionSystem) == 0x000008, "Wrong alignment on UAIPerceptionSystem");
static_assert(sizeof(UAIPerceptionSystem) == 0x000130, "Wrong size on UAIPerceptionSystem");
static_assert(offsetof(UAIPerceptionSystem, Senses) == 0x000088, "Member 'UAIPerceptionSystem::Senses' has a wrong offset!");
static_assert(offsetof(UAIPerceptionSystem, PerceptionAgingRate) == 0x000098, "Member 'UAIPerceptionSystem::PerceptionAgingRate' has a wrong offset!");
// Class AIModule.AIResourceInterface
// 0x0000 (0x0000 - 0x0000)
class IAIResourceInterface final
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIResourceInterface">();
}
static class IAIResourceInterface* GetDefaultObj()
{
return GetDefaultObjImpl<IAIResourceInterface>();
}
class UObject* AsUObject()
{
return reinterpret_cast<UObject*>(this);
}
const class UObject* AsUObject() const
{
return reinterpret_cast<const UObject*>(this);
}
};
static_assert(alignof(IAIResourceInterface) == 0x000001, "Wrong alignment on IAIResourceInterface");
static_assert(sizeof(IAIResourceInterface) == 0x000001, "Wrong size on IAIResourceInterface");
// Class AIModule.AIResource_Movement
// 0x0000 (0x0038 - 0x0038)
class UAIResource_Movement final : public UGameplayTaskResource
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIResource_Movement">();
}
static class UAIResource_Movement* GetDefaultObj()
{
return GetDefaultObjImpl<UAIResource_Movement>();
}
};
static_assert(alignof(UAIResource_Movement) == 0x000008, "Wrong alignment on UAIResource_Movement");
static_assert(sizeof(UAIResource_Movement) == 0x000038, "Wrong size on UAIResource_Movement");
// Class AIModule.BTTask_RunBehavior
// 0x0008 (0x0078 - 0x0070)
class UBTTask_RunBehavior final : public UBTTaskNode
{
public:
class UBehaviorTree* BehaviorAsset; // 0x0070(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_RunBehavior">();
}
static class UBTTask_RunBehavior* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_RunBehavior>();
}
};
static_assert(alignof(UBTTask_RunBehavior) == 0x000008, "Wrong alignment on UBTTask_RunBehavior");
static_assert(sizeof(UBTTask_RunBehavior) == 0x000078, "Wrong size on UBTTask_RunBehavior");
static_assert(offsetof(UBTTask_RunBehavior, BehaviorAsset) == 0x000070, "Member 'UBTTask_RunBehavior::BehaviorAsset' has a wrong offset!");
// Class AIModule.AIResource_Logic
// 0x0000 (0x0038 - 0x0038)
class UAIResource_Logic final : public UGameplayTaskResource
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AIResource_Logic">();
}
static class UAIResource_Logic* GetDefaultObj()
{
return GetDefaultObjImpl<UAIResource_Logic>();
}
};
static_assert(alignof(UAIResource_Logic) == 0x000008, "Wrong alignment on UAIResource_Logic");
static_assert(sizeof(UAIResource_Logic) == 0x000038, "Wrong size on UAIResource_Logic");
// Class AIModule.EnvQueryTest_Project
// 0x0030 (0x0228 - 0x01F8)
class UEnvQueryTest_Project final : public UEnvQueryTest
{
public:
struct FEnvTraceData ProjectionData; // 0x01F8(0x0030)(Edit, DisableEditOnInstance, NoDestructor, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Project">();
}
static class UEnvQueryTest_Project* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Project>();
}
};
static_assert(alignof(UEnvQueryTest_Project) == 0x000008, "Wrong alignment on UEnvQueryTest_Project");
static_assert(sizeof(UEnvQueryTest_Project) == 0x000228, "Wrong size on UEnvQueryTest_Project");
static_assert(offsetof(UEnvQueryTest_Project, ProjectionData) == 0x0001F8, "Member 'UEnvQueryTest_Project::ProjectionData' has a wrong offset!");
// Class AIModule.AISense_Blueprint
// 0x0028 (0x00A8 - 0x0080)
class UAISense_Blueprint final : public UAISense
{
public:
TSubclassOf<class UUserDefinedStruct> ListenerDataType; // 0x0080(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<class UAIPerceptionComponent*> ListenerContainer; // 0x0088(0x0010)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
TArray<class UAISenseEvent*> UnprocessedEvents; // 0x0098(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
public:
void K2_OnNewPawn(class APawn* NewPawn);
void OnListenerRegistered(class AActor* ActorListener, class UAIPerceptionComponent* PerceptionComponent);
void OnListenerUnregistered(class AActor* ActorListener, class UAIPerceptionComponent* PerceptionComponent);
void OnListenerUpdated(class AActor* ActorListener, class UAIPerceptionComponent* PerceptionComponent);
float OnUpdate(const TArray<class UAISenseEvent*>& EventsToProcess);
void GetAllListenerActors(TArray<class AActor*>* ListenerActors) const;
void GetAllListenerComponents(TArray<class UAIPerceptionComponent*>* ListenerComponents) const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense_Blueprint">();
}
static class UAISense_Blueprint* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense_Blueprint>();
}
};
static_assert(alignof(UAISense_Blueprint) == 0x000008, "Wrong alignment on UAISense_Blueprint");
static_assert(sizeof(UAISense_Blueprint) == 0x0000A8, "Wrong size on UAISense_Blueprint");
static_assert(offsetof(UAISense_Blueprint, ListenerDataType) == 0x000080, "Member 'UAISense_Blueprint::ListenerDataType' has a wrong offset!");
static_assert(offsetof(UAISense_Blueprint, ListenerContainer) == 0x000088, "Member 'UAISense_Blueprint::ListenerContainer' has a wrong offset!");
static_assert(offsetof(UAISense_Blueprint, UnprocessedEvents) == 0x000098, "Member 'UAISense_Blueprint::UnprocessedEvents' has a wrong offset!");
// Class AIModule.AISense_Damage
// 0x0010 (0x0090 - 0x0080)
class UAISense_Damage final : public UAISense
{
public:
TArray<struct FAIDamageEvent> RegisteredEvents; // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
public:
static void ReportDamageEvent(class UObject* WorldContextObject, class AActor* DamagedActor, class AActor* Instigator, float DamageAmount, const struct FVector& EventLocation, const struct FVector& HitLocation, class FName Tag);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense_Damage">();
}
static class UAISense_Damage* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense_Damage>();
}
};
static_assert(alignof(UAISense_Damage) == 0x000008, "Wrong alignment on UAISense_Damage");
static_assert(sizeof(UAISense_Damage) == 0x000090, "Wrong size on UAISense_Damage");
static_assert(offsetof(UAISense_Damage, RegisteredEvents) == 0x000080, "Member 'UAISense_Damage::RegisteredEvents' has a wrong offset!");
// Class AIModule.EnvQueryItemType
// 0x0008 (0x0030 - 0x0028)
class UEnvQueryItemType : public UObject
{
public:
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryItemType">();
}
static class UEnvQueryItemType* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryItemType>();
}
};
static_assert(alignof(UEnvQueryItemType) == 0x000008, "Wrong alignment on UEnvQueryItemType");
static_assert(sizeof(UEnvQueryItemType) == 0x000030, "Wrong size on UEnvQueryItemType");
// Class AIModule.EnvQueryItemType_VectorBase
// 0x0000 (0x0030 - 0x0030)
class UEnvQueryItemType_VectorBase : public UEnvQueryItemType
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryItemType_VectorBase">();
}
static class UEnvQueryItemType_VectorBase* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryItemType_VectorBase>();
}
};
static_assert(alignof(UEnvQueryItemType_VectorBase) == 0x000008, "Wrong alignment on UEnvQueryItemType_VectorBase");
static_assert(sizeof(UEnvQueryItemType_VectorBase) == 0x000030, "Wrong size on UEnvQueryItemType_VectorBase");
// Class AIModule.EnvQueryItemType_Direction
// 0x0000 (0x0030 - 0x0030)
class UEnvQueryItemType_Direction final : public UEnvQueryItemType_VectorBase
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryItemType_Direction">();
}
static class UEnvQueryItemType_Direction* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryItemType_Direction>();
}
};
static_assert(alignof(UEnvQueryItemType_Direction) == 0x000008, "Wrong alignment on UEnvQueryItemType_Direction");
static_assert(sizeof(UEnvQueryItemType_Direction) == 0x000030, "Wrong size on UEnvQueryItemType_Direction");
// Class AIModule.AISense_Hearing
// 0x0068 (0x00E8 - 0x0080)
class UAISense_Hearing final : public UAISense
{
public:
TArray<struct FAINoiseEvent> NoiseEvents; // 0x0080(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
float SpeedOfSoundSq; // 0x0090(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_94[0x54]; // 0x0094(0x0054)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static void ReportNoiseEvent(class UObject* WorldContextObject, const struct FVector& NoiseLocation, float Loudness, class AActor* Instigator, float MaxRange, class FName Tag);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense_Hearing">();
}
static class UAISense_Hearing* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense_Hearing>();
}
};
static_assert(alignof(UAISense_Hearing) == 0x000008, "Wrong alignment on UAISense_Hearing");
static_assert(sizeof(UAISense_Hearing) == 0x0000E8, "Wrong size on UAISense_Hearing");
static_assert(offsetof(UAISense_Hearing, NoiseEvents) == 0x000080, "Member 'UAISense_Hearing::NoiseEvents' has a wrong offset!");
static_assert(offsetof(UAISense_Hearing, SpeedOfSoundSq) == 0x000090, "Member 'UAISense_Hearing::SpeedOfSoundSq' has a wrong offset!");
// Class AIModule.AISense_Prediction
// 0x0010 (0x0090 - 0x0080)
class UAISense_Prediction final : public UAISense
{
public:
TArray<struct FAIPredictionEvent> RegisteredEvents; // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
public:
static void RequestControllerPredictionEvent(class AAIController* Requestor, class AActor* PredictedActor, float PredictionTime);
static void RequestPawnPredictionEvent(class APawn* Requestor, class AActor* PredictedActor, float PredictionTime);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense_Prediction">();
}
static class UAISense_Prediction* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense_Prediction>();
}
};
static_assert(alignof(UAISense_Prediction) == 0x000008, "Wrong alignment on UAISense_Prediction");
static_assert(sizeof(UAISense_Prediction) == 0x000090, "Wrong size on UAISense_Prediction");
static_assert(offsetof(UAISense_Prediction, RegisteredEvents) == 0x000080, "Member 'UAISense_Prediction::RegisteredEvents' has a wrong offset!");
// Class AIModule.AISense_Sight
// 0x00F0 (0x0170 - 0x0080)
class UAISense_Sight final : public UAISense
{
public:
uint8 Pad_80[0xC8]; // 0x0080(0x00C8)(Fixing Size After Last Property [ Dumper-7 ])
int32 MaxTracesPerTick; // 0x0148(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
int32 MinQueriesPerTimeSliceCheck; // 0x014C(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
double MaxTimeSlicePerTick; // 0x0150(0x0008)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float HighImportanceQueryDistanceThreshold; // 0x0158(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_15C[0x4]; // 0x015C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
float MaxQueryImportance; // 0x0160(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float SightLimitQueryImportance; // 0x0164(0x0004)(Edit, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_168[0x8]; // 0x0168(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense_Sight">();
}
static class UAISense_Sight* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense_Sight>();
}
};
static_assert(alignof(UAISense_Sight) == 0x000008, "Wrong alignment on UAISense_Sight");
static_assert(sizeof(UAISense_Sight) == 0x000170, "Wrong size on UAISense_Sight");
static_assert(offsetof(UAISense_Sight, MaxTracesPerTick) == 0x000148, "Member 'UAISense_Sight::MaxTracesPerTick' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, MinQueriesPerTimeSliceCheck) == 0x00014C, "Member 'UAISense_Sight::MinQueriesPerTimeSliceCheck' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, MaxTimeSlicePerTick) == 0x000150, "Member 'UAISense_Sight::MaxTimeSlicePerTick' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, HighImportanceQueryDistanceThreshold) == 0x000158, "Member 'UAISense_Sight::HighImportanceQueryDistanceThreshold' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, MaxQueryImportance) == 0x000160, "Member 'UAISense_Sight::MaxQueryImportance' has a wrong offset!");
static_assert(offsetof(UAISense_Sight, SightLimitQueryImportance) == 0x000164, "Member 'UAISense_Sight::SightLimitQueryImportance' has a wrong offset!");
// Class AIModule.AISense_Touch
// 0x0010 (0x0090 - 0x0080)
class UAISense_Touch final : public UAISense
{
public:
TArray<struct FAITouchEvent> RegisteredEvents; // 0x0080(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISense_Touch">();
}
static class UAISense_Touch* GetDefaultObj()
{
return GetDefaultObjImpl<UAISense_Touch>();
}
};
static_assert(alignof(UAISense_Touch) == 0x000008, "Wrong alignment on UAISense_Touch");
static_assert(sizeof(UAISense_Touch) == 0x000090, "Wrong size on UAISense_Touch");
static_assert(offsetof(UAISense_Touch, RegisteredEvents) == 0x000080, "Member 'UAISense_Touch::RegisteredEvents' has a wrong offset!");
// Class AIModule.AISenseBlueprintListener
// 0x0000 (0x0108 - 0x0108)
class UAISenseBlueprintListener final : public UUserDefinedStruct
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseBlueprintListener">();
}
static class UAISenseBlueprintListener* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseBlueprintListener>();
}
};
static_assert(alignof(UAISenseBlueprintListener) == 0x000008, "Wrong alignment on UAISenseBlueprintListener");
static_assert(sizeof(UAISenseBlueprintListener) == 0x000108, "Wrong size on UAISenseBlueprintListener");
// Class AIModule.AISenseConfig_Blueprint
// 0x0008 (0x0050 - 0x0048)
class UAISenseConfig_Blueprint final : public UAISenseConfig
{
public:
TSubclassOf<class UAISense_Blueprint> Implementation; // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig_Blueprint">();
}
static class UAISenseConfig_Blueprint* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig_Blueprint>();
}
};
static_assert(alignof(UAISenseConfig_Blueprint) == 0x000008, "Wrong alignment on UAISenseConfig_Blueprint");
static_assert(sizeof(UAISenseConfig_Blueprint) == 0x000050, "Wrong size on UAISenseConfig_Blueprint");
static_assert(offsetof(UAISenseConfig_Blueprint, Implementation) == 0x000048, "Member 'UAISenseConfig_Blueprint::Implementation' has a wrong offset!");
// Class AIModule.AISenseConfig_Hearing
// 0x0018 (0x0060 - 0x0048)
class UAISenseConfig_Hearing final : public UAISenseConfig
{
public:
TSubclassOf<class UAISense_Hearing> Implementation; // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HearingRange; // 0x0050(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LoSHearingRange; // 0x0054(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 bUseLoSHearing : 1; // 0x0058(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_59[0x3]; // 0x0059(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
struct FAISenseAffiliationFilter DetectionByAffiliation; // 0x005C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig_Hearing">();
}
static class UAISenseConfig_Hearing* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig_Hearing>();
}
};
static_assert(alignof(UAISenseConfig_Hearing) == 0x000008, "Wrong alignment on UAISenseConfig_Hearing");
static_assert(sizeof(UAISenseConfig_Hearing) == 0x000060, "Wrong size on UAISenseConfig_Hearing");
static_assert(offsetof(UAISenseConfig_Hearing, Implementation) == 0x000048, "Member 'UAISenseConfig_Hearing::Implementation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Hearing, HearingRange) == 0x000050, "Member 'UAISenseConfig_Hearing::HearingRange' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Hearing, LoSHearingRange) == 0x000054, "Member 'UAISenseConfig_Hearing::LoSHearingRange' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Hearing, DetectionByAffiliation) == 0x00005C, "Member 'UAISenseConfig_Hearing::DetectionByAffiliation' has a wrong offset!");
// Class AIModule.AISenseConfig_Prediction
// 0x0000 (0x0048 - 0x0048)
class UAISenseConfig_Prediction final : public UAISenseConfig
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig_Prediction">();
}
static class UAISenseConfig_Prediction* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig_Prediction>();
}
};
static_assert(alignof(UAISenseConfig_Prediction) == 0x000008, "Wrong alignment on UAISenseConfig_Prediction");
static_assert(sizeof(UAISenseConfig_Prediction) == 0x000048, "Wrong size on UAISenseConfig_Prediction");
// Class AIModule.AISenseConfig_Sight
// 0x0028 (0x0070 - 0x0048)
class UAISenseConfig_Sight final : public UAISenseConfig
{
public:
TSubclassOf<class UAISense_Sight> Implementation; // 0x0048(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, NoClear, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SightRadius; // 0x0050(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LoseSightRadius; // 0x0054(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PeripheralVisionAngleDegrees; // 0x0058(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FAISenseAffiliationFilter DetectionByAffiliation; // 0x005C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
float AutoSuccessRangeFromLastSeenLocation; // 0x0060(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float PointOfViewBackwardOffset; // 0x0064(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float NearClippingRadius; // 0x0068(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_6C[0x4]; // 0x006C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig_Sight">();
}
static class UAISenseConfig_Sight* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig_Sight>();
}
};
static_assert(alignof(UAISenseConfig_Sight) == 0x000008, "Wrong alignment on UAISenseConfig_Sight");
static_assert(sizeof(UAISenseConfig_Sight) == 0x000070, "Wrong size on UAISenseConfig_Sight");
static_assert(offsetof(UAISenseConfig_Sight, Implementation) == 0x000048, "Member 'UAISenseConfig_Sight::Implementation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, SightRadius) == 0x000050, "Member 'UAISenseConfig_Sight::SightRadius' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, LoseSightRadius) == 0x000054, "Member 'UAISenseConfig_Sight::LoseSightRadius' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, PeripheralVisionAngleDegrees) == 0x000058, "Member 'UAISenseConfig_Sight::PeripheralVisionAngleDegrees' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, DetectionByAffiliation) == 0x00005C, "Member 'UAISenseConfig_Sight::DetectionByAffiliation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, AutoSuccessRangeFromLastSeenLocation) == 0x000060, "Member 'UAISenseConfig_Sight::AutoSuccessRangeFromLastSeenLocation' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, PointOfViewBackwardOffset) == 0x000064, "Member 'UAISenseConfig_Sight::PointOfViewBackwardOffset' has a wrong offset!");
static_assert(offsetof(UAISenseConfig_Sight, NearClippingRadius) == 0x000068, "Member 'UAISenseConfig_Sight::NearClippingRadius' has a wrong offset!");
// Class AIModule.AISenseConfig_Team
// 0x0000 (0x0048 - 0x0048)
class UAISenseConfig_Team final : public UAISenseConfig
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseConfig_Team">();
}
static class UAISenseConfig_Team* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseConfig_Team>();
}
};
static_assert(alignof(UAISenseConfig_Team) == 0x000008, "Wrong alignment on UAISenseConfig_Team");
static_assert(sizeof(UAISenseConfig_Team) == 0x000048, "Wrong size on UAISenseConfig_Team");
// Class AIModule.PawnAction
// 0x0068 (0x0090 - 0x0028)
class UPawnAction : public UObject
{
public:
class UPawnAction* ChildAction; // 0x0028(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UPawnAction* ParentAction; // 0x0030(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UPawnActionsComponent* OwnerComponent; // 0x0038(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UObject* Instigator; // 0x0040(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
class UBrainComponent* BrainComp; // 0x0048(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_50[0x30]; // 0x0050(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bAllowNewSameClassInstance : 1; // 0x0080(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bReplaceActiveSameClassInstance : 1; // 0x0080(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bShouldPauseMovement : 1; // 0x0080(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bAlwaysNotifyOnFinished : 1; // 0x0080(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_81[0xF]; // 0x0081(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UPawnAction* CreateActionInstance(class UObject* WorldContextObject, TSubclassOf<class UPawnAction> ActionClass);
void Finish(EPawnActionResult WithResult);
EAIRequestPriority GetActionPriority();
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnAction">();
}
static class UPawnAction* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnAction>();
}
};
static_assert(alignof(UPawnAction) == 0x000008, "Wrong alignment on UPawnAction");
static_assert(sizeof(UPawnAction) == 0x000090, "Wrong size on UPawnAction");
static_assert(offsetof(UPawnAction, ChildAction) == 0x000028, "Member 'UPawnAction::ChildAction' has a wrong offset!");
static_assert(offsetof(UPawnAction, ParentAction) == 0x000030, "Member 'UPawnAction::ParentAction' has a wrong offset!");
static_assert(offsetof(UPawnAction, OwnerComponent) == 0x000038, "Member 'UPawnAction::OwnerComponent' has a wrong offset!");
static_assert(offsetof(UPawnAction, Instigator) == 0x000040, "Member 'UPawnAction::Instigator' has a wrong offset!");
static_assert(offsetof(UPawnAction, BrainComp) == 0x000048, "Member 'UPawnAction::BrainComp' has a wrong offset!");
// Class AIModule.PawnAction_BlueprintBase
// 0x0000 (0x0090 - 0x0090)
class UPawnAction_BlueprintBase final : public UPawnAction
{
public:
void ActionFinished(class APawn* ControlledPawn, EPawnActionResult WithResult);
void ActionPause(class APawn* ControlledPawn);
void ActionResume(class APawn* ControlledPawn);
void ActionStart(class APawn* ControlledPawn);
void ActionTick(class APawn* ControlledPawn, float DeltaSeconds);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnAction_BlueprintBase">();
}
static class UPawnAction_BlueprintBase* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnAction_BlueprintBase>();
}
};
static_assert(alignof(UPawnAction_BlueprintBase) == 0x000008, "Wrong alignment on UPawnAction_BlueprintBase");
static_assert(sizeof(UPawnAction_BlueprintBase) == 0x000090, "Wrong size on UPawnAction_BlueprintBase");
// Class AIModule.AISenseEvent
// 0x0000 (0x0028 - 0x0028)
class UAISenseEvent : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseEvent">();
}
static class UAISenseEvent* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseEvent>();
}
};
static_assert(alignof(UAISenseEvent) == 0x000008, "Wrong alignment on UAISenseEvent");
static_assert(sizeof(UAISenseEvent) == 0x000028, "Wrong size on UAISenseEvent");
// Class AIModule.AISenseEvent_Damage
// 0x0038 (0x0060 - 0x0028)
class UAISenseEvent_Damage final : public UAISenseEvent
{
public:
struct FAIDamageEvent Event; // 0x0028(0x0038)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseEvent_Damage">();
}
static class UAISenseEvent_Damage* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseEvent_Damage>();
}
};
static_assert(alignof(UAISenseEvent_Damage) == 0x000008, "Wrong alignment on UAISenseEvent_Damage");
static_assert(sizeof(UAISenseEvent_Damage) == 0x000060, "Wrong size on UAISenseEvent_Damage");
static_assert(offsetof(UAISenseEvent_Damage, Event) == 0x000028, "Member 'UAISenseEvent_Damage::Event' has a wrong offset!");
// Class AIModule.AISenseEvent_Hearing
// 0x0030 (0x0058 - 0x0028)
class UAISenseEvent_Hearing final : public UAISenseEvent
{
public:
struct FAINoiseEvent Event; // 0x0028(0x0030)(Edit, BlueprintVisible, NoDestructor, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISenseEvent_Hearing">();
}
static class UAISenseEvent_Hearing* GetDefaultObj()
{
return GetDefaultObjImpl<UAISenseEvent_Hearing>();
}
};
static_assert(alignof(UAISenseEvent_Hearing) == 0x000008, "Wrong alignment on UAISenseEvent_Hearing");
static_assert(sizeof(UAISenseEvent_Hearing) == 0x000058, "Wrong size on UAISenseEvent_Hearing");
static_assert(offsetof(UAISenseEvent_Hearing, Event) == 0x000028, "Member 'UAISenseEvent_Hearing::Event' has a wrong offset!");
// Class AIModule.AISightTargetInterface
// 0x0000 (0x0000 - 0x0000)
class IAISightTargetInterface final
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AISightTargetInterface">();
}
static class IAISightTargetInterface* GetDefaultObj()
{
return GetDefaultObjImpl<IAISightTargetInterface>();
}
class UObject* AsUObject()
{
return reinterpret_cast<UObject*>(this);
}
const class UObject* AsUObject() const
{
return reinterpret_cast<const UObject*>(this);
}
};
static_assert(alignof(IAISightTargetInterface) == 0x000001, "Wrong alignment on IAISightTargetInterface");
static_assert(sizeof(IAISightTargetInterface) == 0x000001, "Wrong size on IAISightTargetInterface");
// Class AIModule.AITask_LockLogic
// 0x0000 (0x0070 - 0x0070)
class UAITask_LockLogic final : public UAITask
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AITask_LockLogic">();
}
static class UAITask_LockLogic* GetDefaultObj()
{
return GetDefaultObjImpl<UAITask_LockLogic>();
}
};
static_assert(alignof(UAITask_LockLogic) == 0x000008, "Wrong alignment on UAITask_LockLogic");
static_assert(sizeof(UAITask_LockLogic) == 0x000070, "Wrong size on UAITask_LockLogic");
// Class AIModule.AITask_MoveTo
// 0x00A0 (0x0110 - 0x0070)
class UAITask_MoveTo final : public UAITask
{
public:
TMulticastInlineDelegate<void()> OnRequestFailed; // 0x0070(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
TMulticastInlineDelegate<void(EPathFollowingResult Result, class AAIController* AIController)> OnMoveFinished; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
struct FAIMoveRequest MoveRequest; // 0x0090(0x0040)(Protected, NativeAccessSpecifierProtected)
uint8 Pad_D0[0x40]; // 0x00D0(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UAITask_MoveTo* AIMoveTo(class AAIController* Controller, const struct FVector& GoalLocation, class AActor* GoalActor, float AcceptanceRadius, EAIOptionFlag StopOnOverlap, EAIOptionFlag AcceptPartialPath, bool bUsePathfinding, bool bLockAILogic, bool bUseContinuosGoalTracking, EAIOptionFlag ProjectGoalOnNavigation);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"AITask_MoveTo">();
}
static class UAITask_MoveTo* GetDefaultObj()
{
return GetDefaultObjImpl<UAITask_MoveTo>();
}
};
static_assert(alignof(UAITask_MoveTo) == 0x000008, "Wrong alignment on UAITask_MoveTo");
static_assert(sizeof(UAITask_MoveTo) == 0x000110, "Wrong size on UAITask_MoveTo");
static_assert(offsetof(UAITask_MoveTo, OnRequestFailed) == 0x000070, "Member 'UAITask_MoveTo::OnRequestFailed' has a wrong offset!");
static_assert(offsetof(UAITask_MoveTo, OnMoveFinished) == 0x000080, "Member 'UAITask_MoveTo::OnMoveFinished' has a wrong offset!");
static_assert(offsetof(UAITask_MoveTo, MoveRequest) == 0x000090, "Member 'UAITask_MoveTo::MoveRequest' has a wrong offset!");
// Class AIModule.BehaviorTree
// 0x0040 (0x0068 - 0x0028)
class UBehaviorTree final : public UObject
{
public:
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
class UBTCompositeNode* RootNode; // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UBlackboardData* BlackboardAsset; // 0x0038(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class UBTDecorator*> RootDecorators; // 0x0040(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FBTDecoratorLogic> RootDecoratorOps; // 0x0050(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
uint8 Pad_60[0x8]; // 0x0060(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BehaviorTree">();
}
static class UBehaviorTree* GetDefaultObj()
{
return GetDefaultObjImpl<UBehaviorTree>();
}
};
static_assert(alignof(UBehaviorTree) == 0x000008, "Wrong alignment on UBehaviorTree");
static_assert(sizeof(UBehaviorTree) == 0x000068, "Wrong size on UBehaviorTree");
static_assert(offsetof(UBehaviorTree, RootNode) == 0x000030, "Member 'UBehaviorTree::RootNode' has a wrong offset!");
static_assert(offsetof(UBehaviorTree, BlackboardAsset) == 0x000038, "Member 'UBehaviorTree::BlackboardAsset' has a wrong offset!");
static_assert(offsetof(UBehaviorTree, RootDecorators) == 0x000040, "Member 'UBehaviorTree::RootDecorators' has a wrong offset!");
static_assert(offsetof(UBehaviorTree, RootDecoratorOps) == 0x000050, "Member 'UBehaviorTree::RootDecoratorOps' has a wrong offset!");
// Class AIModule.BehaviorTreeManager
// 0x0028 (0x0050 - 0x0028)
class UBehaviorTreeManager final : public UObject
{
public:
int32 MaxDebuggerSteps; // 0x0028(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_2C[0x4]; // 0x002C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
TArray<struct FBehaviorTreeTemplateInfo> LoadedTemplates; // 0x0030(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
TArray<class UBehaviorTreeComponent*> ActiveComponents; // 0x0040(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BehaviorTreeManager">();
}
static class UBehaviorTreeManager* GetDefaultObj()
{
return GetDefaultObjImpl<UBehaviorTreeManager>();
}
};
static_assert(alignof(UBehaviorTreeManager) == 0x000008, "Wrong alignment on UBehaviorTreeManager");
static_assert(sizeof(UBehaviorTreeManager) == 0x000050, "Wrong size on UBehaviorTreeManager");
static_assert(offsetof(UBehaviorTreeManager, MaxDebuggerSteps) == 0x000028, "Member 'UBehaviorTreeManager::MaxDebuggerSteps' has a wrong offset!");
static_assert(offsetof(UBehaviorTreeManager, LoadedTemplates) == 0x000030, "Member 'UBehaviorTreeManager::LoadedTemplates' has a wrong offset!");
static_assert(offsetof(UBehaviorTreeManager, ActiveComponents) == 0x000040, "Member 'UBehaviorTreeManager::ActiveComponents' has a wrong offset!");
// Class AIModule.BehaviorTreeTypes
// 0x0000 (0x0028 - 0x0028)
class UBehaviorTreeTypes final : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BehaviorTreeTypes">();
}
static class UBehaviorTreeTypes* GetDefaultObj()
{
return GetDefaultObjImpl<UBehaviorTreeTypes>();
}
};
static_assert(alignof(UBehaviorTreeTypes) == 0x000008, "Wrong alignment on UBehaviorTreeTypes");
static_assert(sizeof(UBehaviorTreeTypes) == 0x000028, "Wrong size on UBehaviorTreeTypes");
// Class AIModule.BlackboardComponent
// 0x0108 (0x01B8 - 0x00B0)
class UBlackboardComponent final : public UActorComponent
{
public:
class UBrainComponent* BrainComp; // 0x00B0(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UBlackboardData* DefaultBlackboardAsset; // 0x00B8(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class UBlackboardData* BlackboardAsset; // 0x00C0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_C8[0x20]; // 0x00C8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
TArray<class UBlackboardKeyType*> KeyInstances; // 0x00E8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
uint8 Pad_F8[0xC0]; // 0x00F8(0x00C0)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void ClearValue(const class FName& KeyName);
void SetValueAsBool(const class FName& KeyName, bool BoolValue);
void SetValueAsClass(const class FName& KeyName, class UClass* ClassValue);
void SetValueAsEnum(const class FName& KeyName, uint8 EnumValue);
void SetValueAsFloat(const class FName& KeyName, float FloatValue);
void SetValueAsInt(const class FName& KeyName, int32 IntValue);
void SetValueAsName(const class FName& KeyName, class FName NameValue);
void SetValueAsObject(const class FName& KeyName, class UObject* ObjectValue);
void SetValueAsRotator(const class FName& KeyName, const struct FRotator& VectorValue);
void SetValueAsString(const class FName& KeyName, const class FString& StringValue);
void SetValueAsVector(const class FName& KeyName, const struct FVector& VectorValue);
bool GetLocationFromEntry(const class FName& KeyName, struct FVector* ResultLocation) const;
bool GetRotationFromEntry(const class FName& KeyName, struct FRotator* ResultRotation) const;
bool GetValueAsBool(const class FName& KeyName) const;
class UClass* GetValueAsClass(const class FName& KeyName) const;
uint8 GetValueAsEnum(const class FName& KeyName) const;
float GetValueAsFloat(const class FName& KeyName) const;
int32 GetValueAsInt(const class FName& KeyName) const;
class FName GetValueAsName(const class FName& KeyName) const;
class UObject* GetValueAsObject(const class FName& KeyName) const;
struct FRotator GetValueAsRotator(const class FName& KeyName) const;
class FString GetValueAsString(const class FName& KeyName) const;
struct FVector GetValueAsVector(const class FName& KeyName) const;
bool IsVectorValueSet(const class FName& KeyName) const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardComponent">();
}
static class UBlackboardComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardComponent>();
}
};
static_assert(alignof(UBlackboardComponent) == 0x000008, "Wrong alignment on UBlackboardComponent");
static_assert(sizeof(UBlackboardComponent) == 0x0001B8, "Wrong size on UBlackboardComponent");
static_assert(offsetof(UBlackboardComponent, BrainComp) == 0x0000B0, "Member 'UBlackboardComponent::BrainComp' has a wrong offset!");
static_assert(offsetof(UBlackboardComponent, DefaultBlackboardAsset) == 0x0000B8, "Member 'UBlackboardComponent::DefaultBlackboardAsset' has a wrong offset!");
static_assert(offsetof(UBlackboardComponent, BlackboardAsset) == 0x0000C0, "Member 'UBlackboardComponent::BlackboardAsset' has a wrong offset!");
static_assert(offsetof(UBlackboardComponent, KeyInstances) == 0x0000E8, "Member 'UBlackboardComponent::KeyInstances' has a wrong offset!");
// Class AIModule.BlackboardKeyType_Bool
// 0x0000 (0x0030 - 0x0030)
class UBlackboardKeyType_Bool final : public UBlackboardKeyType
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Bool">();
}
static class UBlackboardKeyType_Bool* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Bool>();
}
};
static_assert(alignof(UBlackboardKeyType_Bool) == 0x000008, "Wrong alignment on UBlackboardKeyType_Bool");
static_assert(sizeof(UBlackboardKeyType_Bool) == 0x000030, "Wrong size on UBlackboardKeyType_Bool");
// Class AIModule.BlackboardKeyType_Class
// 0x0008 (0x0038 - 0x0030)
class UBlackboardKeyType_Class final : public UBlackboardKeyType
{
public:
class UClass* BaseClass; // 0x0030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Class">();
}
static class UBlackboardKeyType_Class* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Class>();
}
};
static_assert(alignof(UBlackboardKeyType_Class) == 0x000008, "Wrong alignment on UBlackboardKeyType_Class");
static_assert(sizeof(UBlackboardKeyType_Class) == 0x000038, "Wrong size on UBlackboardKeyType_Class");
static_assert(offsetof(UBlackboardKeyType_Class, BaseClass) == 0x000030, "Member 'UBlackboardKeyType_Class::BaseClass' has a wrong offset!");
// Class AIModule.BlackboardKeyType_Enum
// 0x0020 (0x0050 - 0x0030)
class UBlackboardKeyType_Enum final : public UBlackboardKeyType
{
public:
class UEnum* EnumType; // 0x0030(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class FString EnumName; // 0x0038(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 bIsEnumNameValid : 1; // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_49[0x7]; // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Enum">();
}
static class UBlackboardKeyType_Enum* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Enum>();
}
};
static_assert(alignof(UBlackboardKeyType_Enum) == 0x000008, "Wrong alignment on UBlackboardKeyType_Enum");
static_assert(sizeof(UBlackboardKeyType_Enum) == 0x000050, "Wrong size on UBlackboardKeyType_Enum");
static_assert(offsetof(UBlackboardKeyType_Enum, EnumType) == 0x000030, "Member 'UBlackboardKeyType_Enum::EnumType' has a wrong offset!");
static_assert(offsetof(UBlackboardKeyType_Enum, EnumName) == 0x000038, "Member 'UBlackboardKeyType_Enum::EnumName' has a wrong offset!");
// Class AIModule.PawnSensingComponent
// 0x0048 (0x00F8 - 0x00B0)
class UPawnSensingComponent final : public UActorComponent
{
public:
float HearingThreshold; // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float LOSHearingThreshold; // 0x00B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SightRadius; // 0x00B8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float SensingInterval; // 0x00BC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float HearingMaxSoundAge; // 0x00C0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 bEnableSensingUpdates : 1; // 0x00C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bOnlySensePlayers : 1; // 0x00C4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bSeePawns : 1; // 0x00C4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bHearNoises : 1; // 0x00C4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_C5[0xB]; // 0x00C5(0x000B)(Fixing Size After Last Property [ Dumper-7 ])
TMulticastInlineDelegate<void(class APawn* Pawn)> OnSeePawn; // 0x00D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
TMulticastInlineDelegate<void(class APawn* Instigator, const struct FVector& Location, float Volume)> OnHearNoise; // 0x00E0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
float PeripheralVisionAngle; // 0x00F0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float PeripheralVisionCosine; // 0x00F4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
void SetPeripheralVisionAngle(const float NewPeripheralVisionAngle);
void SetSensingInterval(const float NewSensingInterval);
void SetSensingUpdatesEnabled(const bool bEnabled);
float GetPeripheralVisionAngle() const;
float GetPeripheralVisionCosine() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnSensingComponent">();
}
static class UPawnSensingComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnSensingComponent>();
}
};
static_assert(alignof(UPawnSensingComponent) == 0x000008, "Wrong alignment on UPawnSensingComponent");
static_assert(sizeof(UPawnSensingComponent) == 0x0000F8, "Wrong size on UPawnSensingComponent");
static_assert(offsetof(UPawnSensingComponent, HearingThreshold) == 0x0000B0, "Member 'UPawnSensingComponent::HearingThreshold' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, LOSHearingThreshold) == 0x0000B4, "Member 'UPawnSensingComponent::LOSHearingThreshold' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, SightRadius) == 0x0000B8, "Member 'UPawnSensingComponent::SightRadius' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, SensingInterval) == 0x0000BC, "Member 'UPawnSensingComponent::SensingInterval' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, HearingMaxSoundAge) == 0x0000C0, "Member 'UPawnSensingComponent::HearingMaxSoundAge' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, OnSeePawn) == 0x0000D0, "Member 'UPawnSensingComponent::OnSeePawn' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, OnHearNoise) == 0x0000E0, "Member 'UPawnSensingComponent::OnHearNoise' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, PeripheralVisionAngle) == 0x0000F0, "Member 'UPawnSensingComponent::PeripheralVisionAngle' has a wrong offset!");
static_assert(offsetof(UPawnSensingComponent, PeripheralVisionCosine) == 0x0000F4, "Member 'UPawnSensingComponent::PeripheralVisionCosine' has a wrong offset!");
// Class AIModule.BlackboardKeyType_Float
// 0x0000 (0x0030 - 0x0030)
class UBlackboardKeyType_Float final : public UBlackboardKeyType
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Float">();
}
static class UBlackboardKeyType_Float* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Float>();
}
};
static_assert(alignof(UBlackboardKeyType_Float) == 0x000008, "Wrong alignment on UBlackboardKeyType_Float");
static_assert(sizeof(UBlackboardKeyType_Float) == 0x000030, "Wrong size on UBlackboardKeyType_Float");
// Class AIModule.BlackboardKeyType_Int
// 0x0000 (0x0030 - 0x0030)
class UBlackboardKeyType_Int final : public UBlackboardKeyType
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Int">();
}
static class UBlackboardKeyType_Int* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Int>();
}
};
static_assert(alignof(UBlackboardKeyType_Int) == 0x000008, "Wrong alignment on UBlackboardKeyType_Int");
static_assert(sizeof(UBlackboardKeyType_Int) == 0x000030, "Wrong size on UBlackboardKeyType_Int");
// Class AIModule.BlackboardKeyType_Name
// 0x0000 (0x0030 - 0x0030)
class UBlackboardKeyType_Name final : public UBlackboardKeyType
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Name">();
}
static class UBlackboardKeyType_Name* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Name>();
}
};
static_assert(alignof(UBlackboardKeyType_Name) == 0x000008, "Wrong alignment on UBlackboardKeyType_Name");
static_assert(sizeof(UBlackboardKeyType_Name) == 0x000030, "Wrong size on UBlackboardKeyType_Name");
// Class AIModule.BlackboardKeyType_Rotator
// 0x0000 (0x0030 - 0x0030)
class UBlackboardKeyType_Rotator final : public UBlackboardKeyType
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Rotator">();
}
static class UBlackboardKeyType_Rotator* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Rotator>();
}
};
static_assert(alignof(UBlackboardKeyType_Rotator) == 0x000008, "Wrong alignment on UBlackboardKeyType_Rotator");
static_assert(sizeof(UBlackboardKeyType_Rotator) == 0x000030, "Wrong size on UBlackboardKeyType_Rotator");
// Class AIModule.EnvQueryDebugHelpers
// 0x0000 (0x0028 - 0x0028)
class UEnvQueryDebugHelpers final : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryDebugHelpers">();
}
static class UEnvQueryDebugHelpers* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryDebugHelpers>();
}
};
static_assert(alignof(UEnvQueryDebugHelpers) == 0x000008, "Wrong alignment on UEnvQueryDebugHelpers");
static_assert(sizeof(UEnvQueryDebugHelpers) == 0x000028, "Wrong size on UEnvQueryDebugHelpers");
// Class AIModule.BlackboardKeyType_String
// 0x0010 (0x0040 - 0x0030)
class UBlackboardKeyType_String final : public UBlackboardKeyType
{
public:
class FString StringValue; // 0x0030(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_String">();
}
static class UBlackboardKeyType_String* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_String>();
}
};
static_assert(alignof(UBlackboardKeyType_String) == 0x000008, "Wrong alignment on UBlackboardKeyType_String");
static_assert(sizeof(UBlackboardKeyType_String) == 0x000040, "Wrong size on UBlackboardKeyType_String");
static_assert(offsetof(UBlackboardKeyType_String, StringValue) == 0x000030, "Member 'UBlackboardKeyType_String::StringValue' has a wrong offset!");
// Class AIModule.BlackboardKeyType_Vector
// 0x0000 (0x0030 - 0x0030)
class UBlackboardKeyType_Vector final : public UBlackboardKeyType
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BlackboardKeyType_Vector">();
}
static class UBlackboardKeyType_Vector* GetDefaultObj()
{
return GetDefaultObjImpl<UBlackboardKeyType_Vector>();
}
};
static_assert(alignof(UBlackboardKeyType_Vector) == 0x000008, "Wrong alignment on UBlackboardKeyType_Vector");
static_assert(sizeof(UBlackboardKeyType_Vector) == 0x000030, "Wrong size on UBlackboardKeyType_Vector");
// Class AIModule.BTComposite_Selector
// 0x0000 (0x0090 - 0x0090)
class UBTComposite_Selector final : public UBTCompositeNode
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTComposite_Selector">();
}
static class UBTComposite_Selector* GetDefaultObj()
{
return GetDefaultObjImpl<UBTComposite_Selector>();
}
};
static_assert(alignof(UBTComposite_Selector) == 0x000008, "Wrong alignment on UBTComposite_Selector");
static_assert(sizeof(UBTComposite_Selector) == 0x000090, "Wrong size on UBTComposite_Selector");
// Class AIModule.BTComposite_Sequence
// 0x0000 (0x0090 - 0x0090)
class UBTComposite_Sequence final : public UBTCompositeNode
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTComposite_Sequence">();
}
static class UBTComposite_Sequence* GetDefaultObj()
{
return GetDefaultObjImpl<UBTComposite_Sequence>();
}
};
static_assert(alignof(UBTComposite_Sequence) == 0x000008, "Wrong alignment on UBTComposite_Sequence");
static_assert(sizeof(UBTComposite_Sequence) == 0x000090, "Wrong size on UBTComposite_Sequence");
// Class AIModule.BTComposite_SimpleParallel
// 0x0008 (0x0098 - 0x0090)
class UBTComposite_SimpleParallel final : public UBTCompositeNode
{
public:
EBTParallelMode FinishMode; // 0x0090(0x0001)(Edit, ZeroConstructor, DisableEditOnTemplate, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_91[0x7]; // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTComposite_SimpleParallel">();
}
static class UBTComposite_SimpleParallel* GetDefaultObj()
{
return GetDefaultObjImpl<UBTComposite_SimpleParallel>();
}
};
static_assert(alignof(UBTComposite_SimpleParallel) == 0x000008, "Wrong alignment on UBTComposite_SimpleParallel");
static_assert(sizeof(UBTComposite_SimpleParallel) == 0x000098, "Wrong size on UBTComposite_SimpleParallel");
static_assert(offsetof(UBTComposite_SimpleParallel, FinishMode) == 0x000090, "Member 'UBTComposite_SimpleParallel::FinishMode' has a wrong offset!");
// Class AIModule.BTDecorator_Blackboard
// 0x0030 (0x00C0 - 0x0090)
class UBTDecorator_Blackboard : public UBTDecorator_BlackboardBase
{
public:
int32 IntValue; // 0x0090(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float FloatValue; // 0x0094(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class FString StringValue; // 0x0098(0x0010)(Edit, ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class FString CachedDescription; // 0x00A8(0x0010)(ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 OperationType; // 0x00B8(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
EBTBlackboardRestart NotifyObserver; // 0x00B9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_BA[0x6]; // 0x00BA(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_Blackboard">();
}
static class UBTDecorator_Blackboard* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_Blackboard>();
}
};
static_assert(alignof(UBTDecorator_Blackboard) == 0x000008, "Wrong alignment on UBTDecorator_Blackboard");
static_assert(sizeof(UBTDecorator_Blackboard) == 0x0000C0, "Wrong size on UBTDecorator_Blackboard");
static_assert(offsetof(UBTDecorator_Blackboard, IntValue) == 0x000090, "Member 'UBTDecorator_Blackboard::IntValue' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, FloatValue) == 0x000094, "Member 'UBTDecorator_Blackboard::FloatValue' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, StringValue) == 0x000098, "Member 'UBTDecorator_Blackboard::StringValue' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, CachedDescription) == 0x0000A8, "Member 'UBTDecorator_Blackboard::CachedDescription' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, OperationType) == 0x0000B8, "Member 'UBTDecorator_Blackboard::OperationType' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Blackboard, NotifyObserver) == 0x0000B9, "Member 'UBTDecorator_Blackboard::NotifyObserver' has a wrong offset!");
// Class AIModule.BTDecorator_BlueprintBase
// 0x0038 (0x00A0 - 0x0068)
class UBTDecorator_BlueprintBase final : public UBTDecorator
{
public:
class AAIController* AIOwner; // 0x0068(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class AActor* ActorOwner; // 0x0070(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<class FName> ObservedKeyNames; // 0x0078(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
uint8 Pad_88[0x10]; // 0x0088(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bShowPropertyDetails : 1; // 0x0098(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bCheckConditionOnlyBlackBoardChanges : 1; // 0x0098(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bIsObservingBB : 1; // 0x0098(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_99[0x7]; // 0x0099(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
bool PerformConditionCheck(class AActor* OwnerActor);
bool PerformConditionCheckAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveExecutionFinish(class AActor* OwnerActor, EBTNodeResult NodeResult);
void ReceiveExecutionFinishAI(class AAIController* OwnerController, class APawn* ControlledPawn, EBTNodeResult NodeResult);
void ReceiveExecutionStart(class AActor* OwnerActor);
void ReceiveExecutionStartAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveObserverActivated(class AActor* OwnerActor);
void ReceiveObserverActivatedAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveObserverDeactivated(class AActor* OwnerActor);
void ReceiveObserverDeactivatedAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveTick(class AActor* OwnerActor, float DeltaSeconds);
void ReceiveTickAI(class AAIController* OwnerController, class APawn* ControlledPawn, float DeltaSeconds);
bool IsDecoratorExecutionActive() const;
bool IsDecoratorObserverActive() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_BlueprintBase">();
}
static class UBTDecorator_BlueprintBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_BlueprintBase>();
}
};
static_assert(alignof(UBTDecorator_BlueprintBase) == 0x000008, "Wrong alignment on UBTDecorator_BlueprintBase");
static_assert(sizeof(UBTDecorator_BlueprintBase) == 0x0000A0, "Wrong size on UBTDecorator_BlueprintBase");
static_assert(offsetof(UBTDecorator_BlueprintBase, AIOwner) == 0x000068, "Member 'UBTDecorator_BlueprintBase::AIOwner' has a wrong offset!");
static_assert(offsetof(UBTDecorator_BlueprintBase, ActorOwner) == 0x000070, "Member 'UBTDecorator_BlueprintBase::ActorOwner' has a wrong offset!");
static_assert(offsetof(UBTDecorator_BlueprintBase, ObservedKeyNames) == 0x000078, "Member 'UBTDecorator_BlueprintBase::ObservedKeyNames' has a wrong offset!");
// Class AIModule.BTDecorator_CheckGameplayTagsOnActor
// 0x0060 (0x00C8 - 0x0068)
class UBTDecorator_CheckGameplayTagsOnActor final : public UBTDecorator
{
public:
struct FBlackboardKeySelector ActorToCheck; // 0x0068(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
EGameplayContainerMatchType TagsToMatch; // 0x0090(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_91[0x7]; // 0x0091(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
struct FGameplayTagContainer GameplayTags; // 0x0098(0x0020)(Edit, Protected, NativeAccessSpecifierProtected)
class FString CachedDescription; // 0x00B8(0x0010)(ZeroConstructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_CheckGameplayTagsOnActor">();
}
static class UBTDecorator_CheckGameplayTagsOnActor* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_CheckGameplayTagsOnActor>();
}
};
static_assert(alignof(UBTDecorator_CheckGameplayTagsOnActor) == 0x000008, "Wrong alignment on UBTDecorator_CheckGameplayTagsOnActor");
static_assert(sizeof(UBTDecorator_CheckGameplayTagsOnActor) == 0x0000C8, "Wrong size on UBTDecorator_CheckGameplayTagsOnActor");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, ActorToCheck) == 0x000068, "Member 'UBTDecorator_CheckGameplayTagsOnActor::ActorToCheck' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, TagsToMatch) == 0x000090, "Member 'UBTDecorator_CheckGameplayTagsOnActor::TagsToMatch' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, GameplayTags) == 0x000098, "Member 'UBTDecorator_CheckGameplayTagsOnActor::GameplayTags' has a wrong offset!");
static_assert(offsetof(UBTDecorator_CheckGameplayTagsOnActor, CachedDescription) == 0x0000B8, "Member 'UBTDecorator_CheckGameplayTagsOnActor::CachedDescription' has a wrong offset!");
// Class AIModule.EnvQueryContext_Item
// 0x0000 (0x0028 - 0x0028)
class UEnvQueryContext_Item final : public UEnvQueryContext
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryContext_Item">();
}
static class UEnvQueryContext_Item* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryContext_Item>();
}
};
static_assert(alignof(UEnvQueryContext_Item) == 0x000008, "Wrong alignment on UEnvQueryContext_Item");
static_assert(sizeof(UEnvQueryContext_Item) == 0x000028, "Wrong size on UEnvQueryContext_Item");
// Class AIModule.BTDecorator_ConditionalLoop
// 0x0000 (0x00C0 - 0x00C0)
class UBTDecorator_ConditionalLoop final : public UBTDecorator_Blackboard
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_ConditionalLoop">();
}
static class UBTDecorator_ConditionalLoop* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_ConditionalLoop>();
}
};
static_assert(alignof(UBTDecorator_ConditionalLoop) == 0x000008, "Wrong alignment on UBTDecorator_ConditionalLoop");
static_assert(sizeof(UBTDecorator_ConditionalLoop) == 0x0000C0, "Wrong size on UBTDecorator_ConditionalLoop");
// Class AIModule.BTDecorator_ConeCheck
// 0x0088 (0x00F0 - 0x0068)
class UBTDecorator_ConeCheck final : public UBTDecorator
{
public:
float ConeHalfAngle; // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_6C[0x4]; // 0x006C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
struct FBlackboardKeySelector ConeOrigin; // 0x0070(0x0028)(Edit, NativeAccessSpecifierPublic)
struct FBlackboardKeySelector ConeDirection; // 0x0098(0x0028)(Edit, NativeAccessSpecifierPublic)
struct FBlackboardKeySelector Observed; // 0x00C0(0x0028)(Edit, NativeAccessSpecifierPublic)
uint8 Pad_E8[0x8]; // 0x00E8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_ConeCheck">();
}
static class UBTDecorator_ConeCheck* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_ConeCheck>();
}
};
static_assert(alignof(UBTDecorator_ConeCheck) == 0x000008, "Wrong alignment on UBTDecorator_ConeCheck");
static_assert(sizeof(UBTDecorator_ConeCheck) == 0x0000F0, "Wrong size on UBTDecorator_ConeCheck");
static_assert(offsetof(UBTDecorator_ConeCheck, ConeHalfAngle) == 0x000068, "Member 'UBTDecorator_ConeCheck::ConeHalfAngle' has a wrong offset!");
static_assert(offsetof(UBTDecorator_ConeCheck, ConeOrigin) == 0x000070, "Member 'UBTDecorator_ConeCheck::ConeOrigin' has a wrong offset!");
static_assert(offsetof(UBTDecorator_ConeCheck, ConeDirection) == 0x000098, "Member 'UBTDecorator_ConeCheck::ConeDirection' has a wrong offset!");
static_assert(offsetof(UBTDecorator_ConeCheck, Observed) == 0x0000C0, "Member 'UBTDecorator_ConeCheck::Observed' has a wrong offset!");
// Class AIModule.BTDecorator_Cooldown
// 0x0008 (0x0070 - 0x0068)
class UBTDecorator_Cooldown final : public UBTDecorator
{
public:
float CooldownTime; // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_6C[0x4]; // 0x006C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_Cooldown">();
}
static class UBTDecorator_Cooldown* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_Cooldown>();
}
};
static_assert(alignof(UBTDecorator_Cooldown) == 0x000008, "Wrong alignment on UBTDecorator_Cooldown");
static_assert(sizeof(UBTDecorator_Cooldown) == 0x000070, "Wrong size on UBTDecorator_Cooldown");
static_assert(offsetof(UBTDecorator_Cooldown, CooldownTime) == 0x000068, "Member 'UBTDecorator_Cooldown::CooldownTime' has a wrong offset!");
// Class AIModule.BTDecorator_DoesPathExist
// 0x0060 (0x00C8 - 0x0068)
class UBTDecorator_DoesPathExist final : public UBTDecorator
{
public:
struct FBlackboardKeySelector BlackboardKeyA; // 0x0068(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
struct FBlackboardKeySelector BlackboardKeyB; // 0x0090(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
uint8 bUseSelf : 1; // 0x00B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_B9[0x3]; // 0x00B9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
EPathExistanceQueryType PathQueryType; // 0x00BC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_BD[0x3]; // 0x00BD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UNavigationQueryFilter> FilterClass; // 0x00C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_DoesPathExist">();
}
static class UBTDecorator_DoesPathExist* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_DoesPathExist>();
}
};
static_assert(alignof(UBTDecorator_DoesPathExist) == 0x000008, "Wrong alignment on UBTDecorator_DoesPathExist");
static_assert(sizeof(UBTDecorator_DoesPathExist) == 0x0000C8, "Wrong size on UBTDecorator_DoesPathExist");
static_assert(offsetof(UBTDecorator_DoesPathExist, BlackboardKeyA) == 0x000068, "Member 'UBTDecorator_DoesPathExist::BlackboardKeyA' has a wrong offset!");
static_assert(offsetof(UBTDecorator_DoesPathExist, BlackboardKeyB) == 0x000090, "Member 'UBTDecorator_DoesPathExist::BlackboardKeyB' has a wrong offset!");
static_assert(offsetof(UBTDecorator_DoesPathExist, PathQueryType) == 0x0000BC, "Member 'UBTDecorator_DoesPathExist::PathQueryType' has a wrong offset!");
static_assert(offsetof(UBTDecorator_DoesPathExist, FilterClass) == 0x0000C0, "Member 'UBTDecorator_DoesPathExist::FilterClass' has a wrong offset!");
// Class AIModule.PawnAction_Repeat
// 0x0020 (0x00B0 - 0x0090)
class UPawnAction_Repeat final : public UPawnAction
{
public:
class UPawnAction* ActionToRepeat; // 0x0090(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class UPawnAction* RecentActionCopy; // 0x0098(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EPawnActionFailHandling ChildFailureHandlingMode; // 0x00A0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_A1[0xF]; // 0x00A1(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnAction_Repeat">();
}
static class UPawnAction_Repeat* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnAction_Repeat>();
}
};
static_assert(alignof(UPawnAction_Repeat) == 0x000008, "Wrong alignment on UPawnAction_Repeat");
static_assert(sizeof(UPawnAction_Repeat) == 0x0000B0, "Wrong size on UPawnAction_Repeat");
static_assert(offsetof(UPawnAction_Repeat, ActionToRepeat) == 0x000090, "Member 'UPawnAction_Repeat::ActionToRepeat' has a wrong offset!");
static_assert(offsetof(UPawnAction_Repeat, RecentActionCopy) == 0x000098, "Member 'UPawnAction_Repeat::RecentActionCopy' has a wrong offset!");
static_assert(offsetof(UPawnAction_Repeat, ChildFailureHandlingMode) == 0x0000A0, "Member 'UPawnAction_Repeat::ChildFailureHandlingMode' has a wrong offset!");
// Class AIModule.BTDecorator_ForceSuccess
// 0x0000 (0x0068 - 0x0068)
class UBTDecorator_ForceSuccess final : public UBTDecorator
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_ForceSuccess">();
}
static class UBTDecorator_ForceSuccess* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_ForceSuccess>();
}
};
static_assert(alignof(UBTDecorator_ForceSuccess) == 0x000008, "Wrong alignment on UBTDecorator_ForceSuccess");
static_assert(sizeof(UBTDecorator_ForceSuccess) == 0x000068, "Wrong size on UBTDecorator_ForceSuccess");
// Class AIModule.BTDecorator_IsAtLocation
// 0x0048 (0x00D8 - 0x0090)
class UBTDecorator_IsAtLocation final : public UBTDecorator_BlackboardBase
{
public:
float AcceptableRadius; // 0x0090(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_94[0x4]; // 0x0094(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
struct FAIDataProviderFloatValue ParametrizedAcceptableRadius; // 0x0098(0x0038)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
EFAIDistanceType GeometricDistanceType; // 0x00D0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_D1[0x3]; // 0x00D1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bUseParametrizedRadius : 1; // 0x00D4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bUseNavAgentGoalLocation : 1; // 0x00D4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bPathFindingBasedTest : 1; // 0x00D4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_D5[0x3]; // 0x00D5(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_IsAtLocation">();
}
static class UBTDecorator_IsAtLocation* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_IsAtLocation>();
}
};
static_assert(alignof(UBTDecorator_IsAtLocation) == 0x000008, "Wrong alignment on UBTDecorator_IsAtLocation");
static_assert(sizeof(UBTDecorator_IsAtLocation) == 0x0000D8, "Wrong size on UBTDecorator_IsAtLocation");
static_assert(offsetof(UBTDecorator_IsAtLocation, AcceptableRadius) == 0x000090, "Member 'UBTDecorator_IsAtLocation::AcceptableRadius' has a wrong offset!");
static_assert(offsetof(UBTDecorator_IsAtLocation, ParametrizedAcceptableRadius) == 0x000098, "Member 'UBTDecorator_IsAtLocation::ParametrizedAcceptableRadius' has a wrong offset!");
static_assert(offsetof(UBTDecorator_IsAtLocation, GeometricDistanceType) == 0x0000D0, "Member 'UBTDecorator_IsAtLocation::GeometricDistanceType' has a wrong offset!");
// Class AIModule.BTDecorator_IsBBEntryOfClass
// 0x0008 (0x0098 - 0x0090)
class UBTDecorator_IsBBEntryOfClass final : public UBTDecorator_BlackboardBase
{
public:
TSubclassOf<class UObject> TestClass; // 0x0090(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_IsBBEntryOfClass">();
}
static class UBTDecorator_IsBBEntryOfClass* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_IsBBEntryOfClass>();
}
};
static_assert(alignof(UBTDecorator_IsBBEntryOfClass) == 0x000008, "Wrong alignment on UBTDecorator_IsBBEntryOfClass");
static_assert(sizeof(UBTDecorator_IsBBEntryOfClass) == 0x000098, "Wrong size on UBTDecorator_IsBBEntryOfClass");
static_assert(offsetof(UBTDecorator_IsBBEntryOfClass, TestClass) == 0x000090, "Member 'UBTDecorator_IsBBEntryOfClass::TestClass' has a wrong offset!");
// Class AIModule.BTDecorator_KeepInCone
// 0x0060 (0x00C8 - 0x0068)
class UBTDecorator_KeepInCone final : public UBTDecorator
{
public:
float ConeHalfAngle; // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_6C[0x4]; // 0x006C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
struct FBlackboardKeySelector ConeOrigin; // 0x0070(0x0028)(Edit, NativeAccessSpecifierPublic)
struct FBlackboardKeySelector Observed; // 0x0098(0x0028)(Edit, NativeAccessSpecifierPublic)
uint8 bUseSelfAsOrigin : 1; // 0x00C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bUseSelfAsObserved : 1; // 0x00C0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_C1[0x7]; // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_KeepInCone">();
}
static class UBTDecorator_KeepInCone* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_KeepInCone>();
}
};
static_assert(alignof(UBTDecorator_KeepInCone) == 0x000008, "Wrong alignment on UBTDecorator_KeepInCone");
static_assert(sizeof(UBTDecorator_KeepInCone) == 0x0000C8, "Wrong size on UBTDecorator_KeepInCone");
static_assert(offsetof(UBTDecorator_KeepInCone, ConeHalfAngle) == 0x000068, "Member 'UBTDecorator_KeepInCone::ConeHalfAngle' has a wrong offset!");
static_assert(offsetof(UBTDecorator_KeepInCone, ConeOrigin) == 0x000070, "Member 'UBTDecorator_KeepInCone::ConeOrigin' has a wrong offset!");
static_assert(offsetof(UBTDecorator_KeepInCone, Observed) == 0x000098, "Member 'UBTDecorator_KeepInCone::Observed' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_OnCircle
// 0x0190 (0x0210 - 0x0080)
class UEnvQueryGenerator_OnCircle final : public UEnvQueryGenerator_ProjectedPoints
{
public:
struct FAIDataProviderFloatValue CircleRadius; // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue SpaceBetween; // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderIntValue NumberOfPoints; // 0x00F0(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
EPointOnCircleSpacingMethod PointOnCircleSpacingMethod; // 0x0128(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_129[0x7]; // 0x0129(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
struct FEnvDirection ArcDirection; // 0x0130(0x0020)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ArcAngle; // 0x0150(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
float AngleRadians; // 0x0188(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_18C[0x4]; // 0x018C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UEnvQueryContext> CircleCenter; // 0x0190(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bIgnoreAnyContextActorsWhenGeneratingCircle; // 0x0198(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_199[0x7]; // 0x0199(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
struct FAIDataProviderFloatValue CircleCenterZOffset; // 0x01A0(0x0038)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FEnvTraceData TraceData; // 0x01D8(0x0030)(Edit, NoDestructor, NativeAccessSpecifierPublic)
uint8 bDefineArc : 1; // 0x0208(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_209[0x7]; // 0x0209(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_OnCircle">();
}
static class UEnvQueryGenerator_OnCircle* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_OnCircle>();
}
};
static_assert(alignof(UEnvQueryGenerator_OnCircle) == 0x000008, "Wrong alignment on UEnvQueryGenerator_OnCircle");
static_assert(sizeof(UEnvQueryGenerator_OnCircle) == 0x000210, "Wrong size on UEnvQueryGenerator_OnCircle");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, CircleRadius) == 0x000080, "Member 'UEnvQueryGenerator_OnCircle::CircleRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, SpaceBetween) == 0x0000B8, "Member 'UEnvQueryGenerator_OnCircle::SpaceBetween' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, NumberOfPoints) == 0x0000F0, "Member 'UEnvQueryGenerator_OnCircle::NumberOfPoints' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, PointOnCircleSpacingMethod) == 0x000128, "Member 'UEnvQueryGenerator_OnCircle::PointOnCircleSpacingMethod' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, ArcDirection) == 0x000130, "Member 'UEnvQueryGenerator_OnCircle::ArcDirection' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, ArcAngle) == 0x000150, "Member 'UEnvQueryGenerator_OnCircle::ArcAngle' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, AngleRadians) == 0x000188, "Member 'UEnvQueryGenerator_OnCircle::AngleRadians' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, CircleCenter) == 0x000190, "Member 'UEnvQueryGenerator_OnCircle::CircleCenter' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, bIgnoreAnyContextActorsWhenGeneratingCircle) == 0x000198, "Member 'UEnvQueryGenerator_OnCircle::bIgnoreAnyContextActorsWhenGeneratingCircle' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, CircleCenterZOffset) == 0x0001A0, "Member 'UEnvQueryGenerator_OnCircle::CircleCenterZOffset' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_OnCircle, TraceData) == 0x0001D8, "Member 'UEnvQueryGenerator_OnCircle::TraceData' has a wrong offset!");
// Class AIModule.BTDecorator_Loop
// 0x0010 (0x0078 - 0x0068)
class UBTDecorator_Loop final : public UBTDecorator
{
public:
int32 NumLoops; // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bInfiniteLoop; // 0x006C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_6D[0x3]; // 0x006D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
float InfiniteLoopTimeoutTime; // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_74[0x4]; // 0x0074(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_Loop">();
}
static class UBTDecorator_Loop* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_Loop>();
}
};
static_assert(alignof(UBTDecorator_Loop) == 0x000008, "Wrong alignment on UBTDecorator_Loop");
static_assert(sizeof(UBTDecorator_Loop) == 0x000078, "Wrong size on UBTDecorator_Loop");
static_assert(offsetof(UBTDecorator_Loop, NumLoops) == 0x000068, "Member 'UBTDecorator_Loop::NumLoops' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Loop, bInfiniteLoop) == 0x00006C, "Member 'UBTDecorator_Loop::bInfiniteLoop' has a wrong offset!");
static_assert(offsetof(UBTDecorator_Loop, InfiniteLoopTimeoutTime) == 0x000070, "Member 'UBTDecorator_Loop::InfiniteLoopTimeoutTime' has a wrong offset!");
// Class AIModule.BTDecorator_ReachedMoveGoal
// 0x0000 (0x0068 - 0x0068)
class UBTDecorator_ReachedMoveGoal final : public UBTDecorator
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_ReachedMoveGoal">();
}
static class UBTDecorator_ReachedMoveGoal* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_ReachedMoveGoal>();
}
};
static_assert(alignof(UBTDecorator_ReachedMoveGoal) == 0x000008, "Wrong alignment on UBTDecorator_ReachedMoveGoal");
static_assert(sizeof(UBTDecorator_ReachedMoveGoal) == 0x000068, "Wrong size on UBTDecorator_ReachedMoveGoal");
// Class AIModule.BTDecorator_SetTagCooldown
// 0x0010 (0x0078 - 0x0068)
class UBTDecorator_SetTagCooldown final : public UBTDecorator
{
public:
struct FGameplayTag CooldownTag; // 0x0068(0x0008)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CooldownDuration; // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAddToExistingDuration; // 0x0074(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_75[0x3]; // 0x0075(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_SetTagCooldown">();
}
static class UBTDecorator_SetTagCooldown* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_SetTagCooldown>();
}
};
static_assert(alignof(UBTDecorator_SetTagCooldown) == 0x000008, "Wrong alignment on UBTDecorator_SetTagCooldown");
static_assert(sizeof(UBTDecorator_SetTagCooldown) == 0x000078, "Wrong size on UBTDecorator_SetTagCooldown");
static_assert(offsetof(UBTDecorator_SetTagCooldown, CooldownTag) == 0x000068, "Member 'UBTDecorator_SetTagCooldown::CooldownTag' has a wrong offset!");
static_assert(offsetof(UBTDecorator_SetTagCooldown, CooldownDuration) == 0x000070, "Member 'UBTDecorator_SetTagCooldown::CooldownDuration' has a wrong offset!");
static_assert(offsetof(UBTDecorator_SetTagCooldown, bAddToExistingDuration) == 0x000074, "Member 'UBTDecorator_SetTagCooldown::bAddToExistingDuration' has a wrong offset!");
// Class AIModule.BTDecorator_TagCooldown
// 0x0010 (0x0078 - 0x0068)
class UBTDecorator_TagCooldown final : public UBTDecorator
{
public:
struct FGameplayTag CooldownTag; // 0x0068(0x0008)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float CooldownDuration; // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAddToExistingDuration; // 0x0074(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bActivatesCooldown; // 0x0075(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_76[0x2]; // 0x0076(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTDecorator_TagCooldown">();
}
static class UBTDecorator_TagCooldown* GetDefaultObj()
{
return GetDefaultObjImpl<UBTDecorator_TagCooldown>();
}
};
static_assert(alignof(UBTDecorator_TagCooldown) == 0x000008, "Wrong alignment on UBTDecorator_TagCooldown");
static_assert(sizeof(UBTDecorator_TagCooldown) == 0x000078, "Wrong size on UBTDecorator_TagCooldown");
static_assert(offsetof(UBTDecorator_TagCooldown, CooldownTag) == 0x000068, "Member 'UBTDecorator_TagCooldown::CooldownTag' has a wrong offset!");
static_assert(offsetof(UBTDecorator_TagCooldown, CooldownDuration) == 0x000070, "Member 'UBTDecorator_TagCooldown::CooldownDuration' has a wrong offset!");
static_assert(offsetof(UBTDecorator_TagCooldown, bAddToExistingDuration) == 0x000074, "Member 'UBTDecorator_TagCooldown::bAddToExistingDuration' has a wrong offset!");
static_assert(offsetof(UBTDecorator_TagCooldown, bActivatesCooldown) == 0x000075, "Member 'UBTDecorator_TagCooldown::bActivatesCooldown' has a wrong offset!");
// Class AIModule.BTFunctionLibrary
// 0x0000 (0x0028 - 0x0028)
class UBTFunctionLibrary final : public UBlueprintFunctionLibrary
{
public:
static void ClearBlackboardValue(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static void ClearBlackboardValueAsVector(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static class AActor* GetBlackboardValueAsActor(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static bool GetBlackboardValueAsBool(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static class UClass* GetBlackboardValueAsClass(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static uint8 GetBlackboardValueAsEnum(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static float GetBlackboardValueAsFloat(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static int32 GetBlackboardValueAsInt(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static class FName GetBlackboardValueAsName(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static class UObject* GetBlackboardValueAsObject(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static struct FRotator GetBlackboardValueAsRotator(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static class FString GetBlackboardValueAsString(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static struct FVector GetBlackboardValueAsVector(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key);
static class UBehaviorTreeComponent* GetOwnerComponent(class UBTNode* NodeOwner);
static class UBlackboardComponent* GetOwnersBlackboard(class UBTNode* NodeOwner);
static void SetBlackboardValueAsBool(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, bool Value);
static void SetBlackboardValueAsClass(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, class UClass* Value);
static void SetBlackboardValueAsEnum(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, uint8 Value);
static void SetBlackboardValueAsFloat(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, float Value);
static void SetBlackboardValueAsInt(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, int32 Value);
static void SetBlackboardValueAsName(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, class FName Value);
static void SetBlackboardValueAsObject(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, class UObject* Value);
static void SetBlackboardValueAsRotator(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, const struct FRotator& Value);
static void SetBlackboardValueAsString(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, const class FString& Value);
static void SetBlackboardValueAsVector(class UBTNode* NodeOwner, const struct FBlackboardKeySelector& Key, const struct FVector& Value);
static void StartUsingExternalEvent(class UBTNode* NodeOwner, class AActor* OwningActor);
static void StopUsingExternalEvent(class UBTNode* NodeOwner);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTFunctionLibrary">();
}
static class UBTFunctionLibrary* GetDefaultObj()
{
return GetDefaultObjImpl<UBTFunctionLibrary>();
}
};
static_assert(alignof(UBTFunctionLibrary) == 0x000008, "Wrong alignment on UBTFunctionLibrary");
static_assert(sizeof(UBTFunctionLibrary) == 0x000028, "Wrong size on UBTFunctionLibrary");
// Class AIModule.BTService_BlackboardBase
// 0x0028 (0x0098 - 0x0070)
class UBTService_BlackboardBase : public UBTService
{
public:
struct FBlackboardKeySelector BlackboardKey; // 0x0070(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTService_BlackboardBase">();
}
static class UBTService_BlackboardBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTService_BlackboardBase>();
}
};
static_assert(alignof(UBTService_BlackboardBase) == 0x000008, "Wrong alignment on UBTService_BlackboardBase");
static_assert(sizeof(UBTService_BlackboardBase) == 0x000098, "Wrong size on UBTService_BlackboardBase");
static_assert(offsetof(UBTService_BlackboardBase, BlackboardKey) == 0x000070, "Member 'UBTService_BlackboardBase::BlackboardKey' has a wrong offset!");
// Class AIModule.BTService_BlueprintBase
// 0x0028 (0x0098 - 0x0070)
class UBTService_BlueprintBase final : public UBTService
{
public:
class AAIController* AIOwner; // 0x0070(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class AActor* ActorOwner; // 0x0078(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_80[0x10]; // 0x0080(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bShowPropertyDetails : 1; // 0x0090(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bShowEventDetails : 1; // 0x0090(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_91[0x7]; // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void ReceiveActivation(class AActor* OwnerActor);
void ReceiveActivationAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveDeactivation(class AActor* OwnerActor);
void ReceiveDeactivationAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveSearchStart(class AActor* OwnerActor);
void ReceiveSearchStartAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveTick(class AActor* OwnerActor, float DeltaSeconds);
void ReceiveTickAI(class AAIController* OwnerController, class APawn* ControlledPawn, float DeltaSeconds);
bool IsServiceActive() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTService_BlueprintBase">();
}
static class UBTService_BlueprintBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTService_BlueprintBase>();
}
};
static_assert(alignof(UBTService_BlueprintBase) == 0x000008, "Wrong alignment on UBTService_BlueprintBase");
static_assert(sizeof(UBTService_BlueprintBase) == 0x000098, "Wrong size on UBTService_BlueprintBase");
static_assert(offsetof(UBTService_BlueprintBase, AIOwner) == 0x000070, "Member 'UBTService_BlueprintBase::AIOwner' has a wrong offset!");
static_assert(offsetof(UBTService_BlueprintBase, ActorOwner) == 0x000078, "Member 'UBTService_BlueprintBase::ActorOwner' has a wrong offset!");
// Class AIModule.BTService_DefaultFocus
// 0x0008 (0x00A0 - 0x0098)
class UBTService_DefaultFocus final : public UBTService_BlackboardBase
{
public:
uint8 FocusPriority; // 0x0098(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_99[0x7]; // 0x0099(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTService_DefaultFocus">();
}
static class UBTService_DefaultFocus* GetDefaultObj()
{
return GetDefaultObjImpl<UBTService_DefaultFocus>();
}
};
static_assert(alignof(UBTService_DefaultFocus) == 0x000008, "Wrong alignment on UBTService_DefaultFocus");
static_assert(sizeof(UBTService_DefaultFocus) == 0x0000A0, "Wrong size on UBTService_DefaultFocus");
static_assert(offsetof(UBTService_DefaultFocus, FocusPriority) == 0x000098, "Member 'UBTService_DefaultFocus::FocusPriority' has a wrong offset!");
// Class AIModule.BTService_RunEQS
// 0x0058 (0x00F0 - 0x0098)
class UBTService_RunEQS final : public UBTService_BlackboardBase
{
public:
struct FEQSParametrizedQueryExecutionRequest EQSRequest; // 0x0098(0x0048)(Edit, Protected, NativeAccessSpecifierProtected)
uint8 Pad_E0[0x10]; // 0x00E0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTService_RunEQS">();
}
static class UBTService_RunEQS* GetDefaultObj()
{
return GetDefaultObjImpl<UBTService_RunEQS>();
}
};
static_assert(alignof(UBTService_RunEQS) == 0x000008, "Wrong alignment on UBTService_RunEQS");
static_assert(sizeof(UBTService_RunEQS) == 0x0000F0, "Wrong size on UBTService_RunEQS");
static_assert(offsetof(UBTService_RunEQS, EQSRequest) == 0x000098, "Member 'UBTService_RunEQS::EQSRequest' has a wrong offset!");
// Class AIModule.BTTask_BlackboardBase
// 0x0028 (0x0098 - 0x0070)
class UBTTask_BlackboardBase : public UBTTaskNode
{
public:
struct FBlackboardKeySelector BlackboardKey; // 0x0070(0x0028)(Edit, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_BlackboardBase">();
}
static class UBTTask_BlackboardBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_BlackboardBase>();
}
};
static_assert(alignof(UBTTask_BlackboardBase) == 0x000008, "Wrong alignment on UBTTask_BlackboardBase");
static_assert(sizeof(UBTTask_BlackboardBase) == 0x000098, "Wrong size on UBTTask_BlackboardBase");
static_assert(offsetof(UBTTask_BlackboardBase, BlackboardKey) == 0x000070, "Member 'UBTTask_BlackboardBase::BlackboardKey' has a wrong offset!");
// Class AIModule.BTTask_BlueprintBase
// 0x0038 (0x00A8 - 0x0070)
class UBTTask_BlueprintBase final : public UBTTaskNode
{
public:
class AAIController* AIOwner; // 0x0070(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
class AActor* ActorOwner; // 0x0078(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
struct FIntervalCountdown TickInterval; // 0x0080(0x0008)(Edit, NoDestructor, Protected, NativeAccessSpecifierProtected)
uint8 Pad_88[0x18]; // 0x0088(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bShowPropertyDetails : 1; // 0x00A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnTemplate, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_A1[0x7]; // 0x00A1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void FinishAbort();
void FinishExecute(bool bSuccess);
void ReceiveAbort(class AActor* OwnerActor);
void ReceiveAbortAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveExecute(class AActor* OwnerActor);
void ReceiveExecuteAI(class AAIController* OwnerController, class APawn* ControlledPawn);
void ReceiveTick(class AActor* OwnerActor, float DeltaSeconds);
void ReceiveTickAI(class AAIController* OwnerController, class APawn* ControlledPawn, float DeltaSeconds);
void SetFinishOnMessage(class FName MessageName);
void SetFinishOnMessageWithId(class FName MessageName, int32 RequestID);
bool IsTaskAborting() const;
bool IsTaskExecuting() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_BlueprintBase">();
}
static class UBTTask_BlueprintBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_BlueprintBase>();
}
};
static_assert(alignof(UBTTask_BlueprintBase) == 0x000008, "Wrong alignment on UBTTask_BlueprintBase");
static_assert(sizeof(UBTTask_BlueprintBase) == 0x0000A8, "Wrong size on UBTTask_BlueprintBase");
static_assert(offsetof(UBTTask_BlueprintBase, AIOwner) == 0x000070, "Member 'UBTTask_BlueprintBase::AIOwner' has a wrong offset!");
static_assert(offsetof(UBTTask_BlueprintBase, ActorOwner) == 0x000078, "Member 'UBTTask_BlueprintBase::ActorOwner' has a wrong offset!");
static_assert(offsetof(UBTTask_BlueprintBase, TickInterval) == 0x000080, "Member 'UBTTask_BlueprintBase::TickInterval' has a wrong offset!");
// Class AIModule.BTTask_FinishWithResult
// 0x0008 (0x0078 - 0x0070)
class UBTTask_FinishWithResult final : public UBTTaskNode
{
public:
EBTNodeResult Result; // 0x0070(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_71[0x7]; // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_FinishWithResult">();
}
static class UBTTask_FinishWithResult* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_FinishWithResult>();
}
};
static_assert(alignof(UBTTask_FinishWithResult) == 0x000008, "Wrong alignment on UBTTask_FinishWithResult");
static_assert(sizeof(UBTTask_FinishWithResult) == 0x000078, "Wrong size on UBTTask_FinishWithResult");
static_assert(offsetof(UBTTask_FinishWithResult, Result) == 0x000070, "Member 'UBTTask_FinishWithResult::Result' has a wrong offset!");
// Class AIModule.BTTask_MoveTo
// 0x0018 (0x00B0 - 0x0098)
class UBTTask_MoveTo : public UBTTask_BlackboardBase
{
public:
float AcceptableRadius; // 0x0098(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_9C[0x4]; // 0x009C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UNavigationQueryFilter> FilterClass; // 0x00A0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
float ObservedBlackboardValueTolerance; // 0x00A8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 bObserveBlackboardValue : 1; // 0x00AC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bAllowStrafe : 1; // 0x00AC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bAllowPartialPath : 1; // 0x00AC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bTrackMovingGoal : 1; // 0x00AC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bProjectGoalLocation : 1; // 0x00AC(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bReachTestIncludesAgentRadius : 1; // 0x00AC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bReachTestIncludesGoalRadius : 1; // 0x00AC(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bStopOnOverlap : 1; // 0x00AC(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bStopOnOverlapNeedsUpdate : 1; // 0x00AD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_AE[0x2]; // 0x00AE(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_MoveTo">();
}
static class UBTTask_MoveTo* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_MoveTo>();
}
};
static_assert(alignof(UBTTask_MoveTo) == 0x000008, "Wrong alignment on UBTTask_MoveTo");
static_assert(sizeof(UBTTask_MoveTo) == 0x0000B0, "Wrong size on UBTTask_MoveTo");
static_assert(offsetof(UBTTask_MoveTo, AcceptableRadius) == 0x000098, "Member 'UBTTask_MoveTo::AcceptableRadius' has a wrong offset!");
static_assert(offsetof(UBTTask_MoveTo, FilterClass) == 0x0000A0, "Member 'UBTTask_MoveTo::FilterClass' has a wrong offset!");
static_assert(offsetof(UBTTask_MoveTo, ObservedBlackboardValueTolerance) == 0x0000A8, "Member 'UBTTask_MoveTo::ObservedBlackboardValueTolerance' has a wrong offset!");
// Class AIModule.BTTask_MoveDirectlyToward
// 0x0008 (0x00B8 - 0x00B0)
class UBTTask_MoveDirectlyToward final : public UBTTask_MoveTo
{
public:
uint8 bDisablePathUpdateOnGoalLocationChange : 1; // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bProjectVectorGoalToNavigation : 1; // 0x00B0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bUpdatedDeprecatedProperties : 1; // 0x00B0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
uint8 Pad_B1[0x7]; // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_MoveDirectlyToward">();
}
static class UBTTask_MoveDirectlyToward* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_MoveDirectlyToward>();
}
};
static_assert(alignof(UBTTask_MoveDirectlyToward) == 0x000008, "Wrong alignment on UBTTask_MoveDirectlyToward");
static_assert(sizeof(UBTTask_MoveDirectlyToward) == 0x0000B8, "Wrong size on UBTTask_MoveDirectlyToward");
// Class AIModule.BTTask_PawnActionBase
// 0x0000 (0x0070 - 0x0070)
class UBTTask_PawnActionBase : public UBTTaskNode
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_PawnActionBase">();
}
static class UBTTask_PawnActionBase* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_PawnActionBase>();
}
};
static_assert(alignof(UBTTask_PawnActionBase) == 0x000008, "Wrong alignment on UBTTask_PawnActionBase");
static_assert(sizeof(UBTTask_PawnActionBase) == 0x000070, "Wrong size on UBTTask_PawnActionBase");
// Class AIModule.BTTask_PlayAnimation
// 0x0040 (0x00B0 - 0x0070)
class UBTTask_PlayAnimation final : public UBTTaskNode
{
public:
class UAnimationAsset* AnimationToPlay; // 0x0070(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 bLooping : 1; // 0x0078(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bNonBlocking : 1; // 0x0078(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_79[0x7]; // 0x0079(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
class UBehaviorTreeComponent* MyOwnerComp; // 0x0080(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
class USkeletalMeshComponent* CachedSkelMesh; // 0x0088(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_90[0x20]; // 0x0090(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_PlayAnimation">();
}
static class UBTTask_PlayAnimation* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_PlayAnimation>();
}
};
static_assert(alignof(UBTTask_PlayAnimation) == 0x000008, "Wrong alignment on UBTTask_PlayAnimation");
static_assert(sizeof(UBTTask_PlayAnimation) == 0x0000B0, "Wrong size on UBTTask_PlayAnimation");
static_assert(offsetof(UBTTask_PlayAnimation, AnimationToPlay) == 0x000070, "Member 'UBTTask_PlayAnimation::AnimationToPlay' has a wrong offset!");
static_assert(offsetof(UBTTask_PlayAnimation, MyOwnerComp) == 0x000080, "Member 'UBTTask_PlayAnimation::MyOwnerComp' has a wrong offset!");
static_assert(offsetof(UBTTask_PlayAnimation, CachedSkelMesh) == 0x000088, "Member 'UBTTask_PlayAnimation::CachedSkelMesh' has a wrong offset!");
// Class AIModule.BTTask_PlaySound
// 0x0008 (0x0078 - 0x0070)
class UBTTask_PlaySound final : public UBTTaskNode
{
public:
class USoundCue* SoundToPlay; // 0x0070(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_PlaySound">();
}
static class UBTTask_PlaySound* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_PlaySound>();
}
};
static_assert(alignof(UBTTask_PlaySound) == 0x000008, "Wrong alignment on UBTTask_PlaySound");
static_assert(sizeof(UBTTask_PlaySound) == 0x000078, "Wrong size on UBTTask_PlaySound");
static_assert(offsetof(UBTTask_PlaySound, SoundToPlay) == 0x000070, "Member 'UBTTask_PlaySound::SoundToPlay' has a wrong offset!");
// Class AIModule.BTTask_PushPawnAction
// 0x0008 (0x0078 - 0x0070)
class UBTTask_PushPawnAction final : public UBTTask_PawnActionBase
{
public:
class UPawnAction* Action; // 0x0070(0x0008)(Edit, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_PushPawnAction">();
}
static class UBTTask_PushPawnAction* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_PushPawnAction>();
}
};
static_assert(alignof(UBTTask_PushPawnAction) == 0x000008, "Wrong alignment on UBTTask_PushPawnAction");
static_assert(sizeof(UBTTask_PushPawnAction) == 0x000078, "Wrong size on UBTTask_PushPawnAction");
static_assert(offsetof(UBTTask_PushPawnAction, Action) == 0x000070, "Member 'UBTTask_PushPawnAction::Action' has a wrong offset!");
// Class AIModule.BTTask_RotateToFaceBBEntry
// 0x0008 (0x00A0 - 0x0098)
class UBTTask_RotateToFaceBBEntry final : public UBTTask_BlackboardBase
{
public:
float Precision; // 0x0098(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_9C[0x4]; // 0x009C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_RotateToFaceBBEntry">();
}
static class UBTTask_RotateToFaceBBEntry* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_RotateToFaceBBEntry>();
}
};
static_assert(alignof(UBTTask_RotateToFaceBBEntry) == 0x000008, "Wrong alignment on UBTTask_RotateToFaceBBEntry");
static_assert(sizeof(UBTTask_RotateToFaceBBEntry) == 0x0000A0, "Wrong size on UBTTask_RotateToFaceBBEntry");
static_assert(offsetof(UBTTask_RotateToFaceBBEntry, Precision) == 0x000098, "Member 'UBTTask_RotateToFaceBBEntry::Precision' has a wrong offset!");
// Class AIModule.BTTask_RunEQSQuery
// 0x00B8 (0x0150 - 0x0098)
class UBTTask_RunEQSQuery final : public UBTTask_BlackboardBase
{
public:
class UEnvQuery* QueryTemplate; // 0x0098(0x0008)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FEnvNamedValue> QueryParams; // 0x00A0(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
TArray<struct FAIDynamicParam> QueryConfig; // 0x00B0(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
EEnvQueryRunMode RunMode; // 0x00C0(0x0001)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_C1[0x7]; // 0x00C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
struct FBlackboardKeySelector EQSQueryBlackboardKey; // 0x00C8(0x0028)(Edit, EditConst, NativeAccessSpecifierPublic)
bool bUseBBKey; // 0x00F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_F1[0x7]; // 0x00F1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
struct FEQSParametrizedQueryExecutionRequest EQSRequest; // 0x00F8(0x0048)(Edit, NativeAccessSpecifierPublic)
uint8 Pad_140[0x10]; // 0x0140(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_RunEQSQuery">();
}
static class UBTTask_RunEQSQuery* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_RunEQSQuery>();
}
};
static_assert(alignof(UBTTask_RunEQSQuery) == 0x000008, "Wrong alignment on UBTTask_RunEQSQuery");
static_assert(sizeof(UBTTask_RunEQSQuery) == 0x000150, "Wrong size on UBTTask_RunEQSQuery");
static_assert(offsetof(UBTTask_RunEQSQuery, QueryTemplate) == 0x000098, "Member 'UBTTask_RunEQSQuery::QueryTemplate' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, QueryParams) == 0x0000A0, "Member 'UBTTask_RunEQSQuery::QueryParams' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, QueryConfig) == 0x0000B0, "Member 'UBTTask_RunEQSQuery::QueryConfig' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, RunMode) == 0x0000C0, "Member 'UBTTask_RunEQSQuery::RunMode' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, EQSQueryBlackboardKey) == 0x0000C8, "Member 'UBTTask_RunEQSQuery::EQSQueryBlackboardKey' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, bUseBBKey) == 0x0000F0, "Member 'UBTTask_RunEQSQuery::bUseBBKey' has a wrong offset!");
static_assert(offsetof(UBTTask_RunEQSQuery, EQSRequest) == 0x0000F8, "Member 'UBTTask_RunEQSQuery::EQSRequest' has a wrong offset!");
// Class AIModule.BTTask_SetTagCooldown
// 0x0010 (0x0080 - 0x0070)
class UBTTask_SetTagCooldown final : public UBTTaskNode
{
public:
struct FGameplayTag CooldownTag; // 0x0070(0x0008)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
bool bAddToExistingDuration; // 0x0078(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_79[0x3]; // 0x0079(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
float CooldownDuration; // 0x007C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"BTTask_SetTagCooldown">();
}
static class UBTTask_SetTagCooldown* GetDefaultObj()
{
return GetDefaultObjImpl<UBTTask_SetTagCooldown>();
}
};
static_assert(alignof(UBTTask_SetTagCooldown) == 0x000008, "Wrong alignment on UBTTask_SetTagCooldown");
static_assert(sizeof(UBTTask_SetTagCooldown) == 0x000080, "Wrong size on UBTTask_SetTagCooldown");
static_assert(offsetof(UBTTask_SetTagCooldown, CooldownTag) == 0x000070, "Member 'UBTTask_SetTagCooldown::CooldownTag' has a wrong offset!");
static_assert(offsetof(UBTTask_SetTagCooldown, bAddToExistingDuration) == 0x000078, "Member 'UBTTask_SetTagCooldown::bAddToExistingDuration' has a wrong offset!");
static_assert(offsetof(UBTTask_SetTagCooldown, CooldownDuration) == 0x00007C, "Member 'UBTTask_SetTagCooldown::CooldownDuration' has a wrong offset!");
// Class AIModule.CrowdAgentInterface
// 0x0000 (0x0000 - 0x0000)
class ICrowdAgentInterface final
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"CrowdAgentInterface">();
}
static class ICrowdAgentInterface* GetDefaultObj()
{
return GetDefaultObjImpl<ICrowdAgentInterface>();
}
class UObject* AsUObject()
{
return reinterpret_cast<UObject*>(this);
}
const class UObject* AsUObject() const
{
return reinterpret_cast<const UObject*>(this);
}
};
static_assert(alignof(ICrowdAgentInterface) == 0x000001, "Wrong alignment on ICrowdAgentInterface");
static_assert(sizeof(ICrowdAgentInterface) == 0x000001, "Wrong size on ICrowdAgentInterface");
// Class AIModule.CrowdManager
// 0x00B0 (0x00D8 - 0x0028)
class UCrowdManager final : public UCrowdManagerBase
{
public:
class ANavigationData* MyNavData; // 0x0028(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<struct FCrowdAvoidanceConfig> AvoidanceConfig; // 0x0030(0x0010)(Edit, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
TArray<struct FCrowdAvoidanceSamplingPattern> SamplingPatterns; // 0x0040(0x0010)(Edit, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
int32 MaxAgents; // 0x0050(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float MaxAgentRadius; // 0x0054(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
int32 MaxAvoidedAgents; // 0x0058(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
int32 MaxAvoidedWalls; // 0x005C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float NavmeshCheckInterval; // 0x0060(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float PathOptimizationInterval; // 0x0064(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float SeparationDirClamp; // 0x0068(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float PathOffsetRadiusMultiplier; // 0x006C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 BitPad_70_0 : 4; // 0x0070(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
uint8 bResolveCollisions : 1; // 0x0070(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_71[0x67]; // 0x0071(0x0067)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"CrowdManager">();
}
static class UCrowdManager* GetDefaultObj()
{
return GetDefaultObjImpl<UCrowdManager>();
}
};
static_assert(alignof(UCrowdManager) == 0x000008, "Wrong alignment on UCrowdManager");
static_assert(sizeof(UCrowdManager) == 0x0000D8, "Wrong size on UCrowdManager");
static_assert(offsetof(UCrowdManager, MyNavData) == 0x000028, "Member 'UCrowdManager::MyNavData' has a wrong offset!");
static_assert(offsetof(UCrowdManager, AvoidanceConfig) == 0x000030, "Member 'UCrowdManager::AvoidanceConfig' has a wrong offset!");
static_assert(offsetof(UCrowdManager, SamplingPatterns) == 0x000040, "Member 'UCrowdManager::SamplingPatterns' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAgents) == 0x000050, "Member 'UCrowdManager::MaxAgents' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAgentRadius) == 0x000054, "Member 'UCrowdManager::MaxAgentRadius' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAvoidedAgents) == 0x000058, "Member 'UCrowdManager::MaxAvoidedAgents' has a wrong offset!");
static_assert(offsetof(UCrowdManager, MaxAvoidedWalls) == 0x00005C, "Member 'UCrowdManager::MaxAvoidedWalls' has a wrong offset!");
static_assert(offsetof(UCrowdManager, NavmeshCheckInterval) == 0x000060, "Member 'UCrowdManager::NavmeshCheckInterval' has a wrong offset!");
static_assert(offsetof(UCrowdManager, PathOptimizationInterval) == 0x000064, "Member 'UCrowdManager::PathOptimizationInterval' has a wrong offset!");
static_assert(offsetof(UCrowdManager, SeparationDirClamp) == 0x000068, "Member 'UCrowdManager::SeparationDirClamp' has a wrong offset!");
static_assert(offsetof(UCrowdManager, PathOffsetRadiusMultiplier) == 0x00006C, "Member 'UCrowdManager::PathOffsetRadiusMultiplier' has a wrong offset!");
// Class AIModule.DetourCrowdAIController
// 0x0000 (0x0328 - 0x0328)
class ADetourCrowdAIController final : public AAIController
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"DetourCrowdAIController">();
}
static class ADetourCrowdAIController* GetDefaultObj()
{
return GetDefaultObjImpl<ADetourCrowdAIController>();
}
};
static_assert(alignof(ADetourCrowdAIController) == 0x000008, "Wrong alignment on ADetourCrowdAIController");
static_assert(sizeof(ADetourCrowdAIController) == 0x000328, "Wrong size on ADetourCrowdAIController");
// Class AIModule.EnvQuery
// 0x0018 (0x0048 - 0x0030)
class UEnvQuery final : public UDataAsset
{
public:
class FName QueryName; // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<class UEnvQueryOption*> Options; // 0x0038(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQuery">();
}
static class UEnvQuery* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQuery>();
}
};
static_assert(alignof(UEnvQuery) == 0x000008, "Wrong alignment on UEnvQuery");
static_assert(sizeof(UEnvQuery) == 0x000048, "Wrong size on UEnvQuery");
static_assert(offsetof(UEnvQuery, QueryName) == 0x000030, "Member 'UEnvQuery::QueryName' has a wrong offset!");
static_assert(offsetof(UEnvQuery, Options) == 0x000038, "Member 'UEnvQuery::Options' has a wrong offset!");
// Class AIModule.EnvQueryContext_BlueprintBase
// 0x0008 (0x0030 - 0x0028)
class UEnvQueryContext_BlueprintBase final : public UEnvQueryContext
{
public:
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void ProvideActorsSet(class UObject* QuerierObject, class AActor* QuerierActor, TArray<class AActor*>* ResultingActorsSet) const;
void ProvideLocationsSet(class UObject* QuerierObject, class AActor* QuerierActor, TArray<struct FVector>* ResultingLocationSet) const;
void ProvideSingleActor(class UObject* QuerierObject, class AActor* QuerierActor, class AActor** ResultingActor) const;
void ProvideSingleLocation(class UObject* QuerierObject, class AActor* QuerierActor, struct FVector* ResultingLocation) const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryContext_BlueprintBase">();
}
static class UEnvQueryContext_BlueprintBase* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryContext_BlueprintBase>();
}
};
static_assert(alignof(UEnvQueryContext_BlueprintBase) == 0x000008, "Wrong alignment on UEnvQueryContext_BlueprintBase");
static_assert(sizeof(UEnvQueryContext_BlueprintBase) == 0x000030, "Wrong size on UEnvQueryContext_BlueprintBase");
// Class AIModule.EnvQueryContext_Querier
// 0x0000 (0x0028 - 0x0028)
class UEnvQueryContext_Querier final : public UEnvQueryContext
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryContext_Querier">();
}
static class UEnvQueryContext_Querier* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryContext_Querier>();
}
};
static_assert(alignof(UEnvQueryContext_Querier) == 0x000008, "Wrong alignment on UEnvQueryContext_Querier");
static_assert(sizeof(UEnvQueryContext_Querier) == 0x000028, "Wrong size on UEnvQueryContext_Querier");
// Class AIModule.EnvQueryGenerator_ActorsOfClass
// 0x0080 (0x00D0 - 0x0050)
class UEnvQueryGenerator_ActorsOfClass final : public UEnvQueryGenerator
{
public:
TSubclassOf<class AActor> SearchedActorClass; // 0x0050(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FAIDataProviderBoolValue GenerateOnlyActorsInRadius; // 0x0058(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue SearchRadius; // 0x0090(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
TSubclassOf<class UEnvQueryContext> SearchCenter; // 0x00C8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_ActorsOfClass">();
}
static class UEnvQueryGenerator_ActorsOfClass* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_ActorsOfClass>();
}
};
static_assert(alignof(UEnvQueryGenerator_ActorsOfClass) == 0x000008, "Wrong alignment on UEnvQueryGenerator_ActorsOfClass");
static_assert(sizeof(UEnvQueryGenerator_ActorsOfClass) == 0x0000D0, "Wrong size on UEnvQueryGenerator_ActorsOfClass");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, SearchedActorClass) == 0x000050, "Member 'UEnvQueryGenerator_ActorsOfClass::SearchedActorClass' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, GenerateOnlyActorsInRadius) == 0x000058, "Member 'UEnvQueryGenerator_ActorsOfClass::GenerateOnlyActorsInRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, SearchRadius) == 0x000090, "Member 'UEnvQueryGenerator_ActorsOfClass::SearchRadius' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_ActorsOfClass, SearchCenter) == 0x0000C8, "Member 'UEnvQueryGenerator_ActorsOfClass::SearchCenter' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_BlueprintBase
// 0x0030 (0x0080 - 0x0050)
class UEnvQueryGenerator_BlueprintBase final : public UEnvQueryGenerator
{
public:
class FText GeneratorsActionDescription; // 0x0050(0x0018)(Edit, NativeAccessSpecifierPublic)
TSubclassOf<class UEnvQueryContext> Context; // 0x0068(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TSubclassOf<class UEnvQueryItemType> GeneratedItemType; // 0x0070(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_78[0x8]; // 0x0078(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
void AddGeneratedActor(class AActor* GeneratedActor) const;
void AddGeneratedVector(const struct FVector& GeneratedVector) const;
void DoItemGeneration(const TArray<struct FVector>& ContextLocations) const;
class UObject* GetQuerier() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_BlueprintBase">();
}
static class UEnvQueryGenerator_BlueprintBase* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_BlueprintBase>();
}
};
static_assert(alignof(UEnvQueryGenerator_BlueprintBase) == 0x000008, "Wrong alignment on UEnvQueryGenerator_BlueprintBase");
static_assert(sizeof(UEnvQueryGenerator_BlueprintBase) == 0x000080, "Wrong size on UEnvQueryGenerator_BlueprintBase");
static_assert(offsetof(UEnvQueryGenerator_BlueprintBase, GeneratorsActionDescription) == 0x000050, "Member 'UEnvQueryGenerator_BlueprintBase::GeneratorsActionDescription' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_BlueprintBase, Context) == 0x000068, "Member 'UEnvQueryGenerator_BlueprintBase::Context' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_BlueprintBase, GeneratedItemType) == 0x000070, "Member 'UEnvQueryGenerator_BlueprintBase::GeneratedItemType' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_Composite
// 0x0020 (0x0070 - 0x0050)
class UEnvQueryGenerator_Composite final : public UEnvQueryGenerator
{
public:
TArray<class UEnvQueryGenerator*> Generators; // 0x0050(0x0010)(Edit, ExportObject, ZeroConstructor, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
uint8 bAllowDifferentItemTypes : 1; // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bHasMatchingItemType : 1; // 0x0060(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_61[0x7]; // 0x0061(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UEnvQueryItemType> ForcedItemType; // 0x0068(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_Composite">();
}
static class UEnvQueryGenerator_Composite* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_Composite>();
}
};
static_assert(alignof(UEnvQueryGenerator_Composite) == 0x000008, "Wrong alignment on UEnvQueryGenerator_Composite");
static_assert(sizeof(UEnvQueryGenerator_Composite) == 0x000070, "Wrong size on UEnvQueryGenerator_Composite");
static_assert(offsetof(UEnvQueryGenerator_Composite, Generators) == 0x000050, "Member 'UEnvQueryGenerator_Composite::Generators' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_Composite, ForcedItemType) == 0x000068, "Member 'UEnvQueryGenerator_Composite::ForcedItemType' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_CurrentLocation
// 0x0008 (0x0058 - 0x0050)
class UEnvQueryGenerator_CurrentLocation final : public UEnvQueryGenerator
{
public:
TSubclassOf<class UEnvQueryContext> QueryContext; // 0x0050(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_CurrentLocation">();
}
static class UEnvQueryGenerator_CurrentLocation* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_CurrentLocation>();
}
};
static_assert(alignof(UEnvQueryGenerator_CurrentLocation) == 0x000008, "Wrong alignment on UEnvQueryGenerator_CurrentLocation");
static_assert(sizeof(UEnvQueryGenerator_CurrentLocation) == 0x000058, "Wrong size on UEnvQueryGenerator_CurrentLocation");
static_assert(offsetof(UEnvQueryGenerator_CurrentLocation, QueryContext) == 0x000050, "Member 'UEnvQueryGenerator_CurrentLocation::QueryContext' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_SimpleGrid
// 0x0078 (0x00F8 - 0x0080)
class UEnvQueryGenerator_SimpleGrid : public UEnvQueryGenerator_ProjectedPoints
{
public:
struct FAIDataProviderFloatValue GridSize; // 0x0080(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue SpaceBetween; // 0x00B8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
TSubclassOf<class UEnvQueryContext> GenerateAround; // 0x00F0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_SimpleGrid">();
}
static class UEnvQueryGenerator_SimpleGrid* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_SimpleGrid>();
}
};
static_assert(alignof(UEnvQueryGenerator_SimpleGrid) == 0x000008, "Wrong alignment on UEnvQueryGenerator_SimpleGrid");
static_assert(sizeof(UEnvQueryGenerator_SimpleGrid) == 0x0000F8, "Wrong size on UEnvQueryGenerator_SimpleGrid");
static_assert(offsetof(UEnvQueryGenerator_SimpleGrid, GridSize) == 0x000080, "Member 'UEnvQueryGenerator_SimpleGrid::GridSize' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_SimpleGrid, SpaceBetween) == 0x0000B8, "Member 'UEnvQueryGenerator_SimpleGrid::SpaceBetween' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_SimpleGrid, GenerateAround) == 0x0000F0, "Member 'UEnvQueryGenerator_SimpleGrid::GenerateAround' has a wrong offset!");
// Class AIModule.EnvQueryGenerator_PathingGrid
// 0x0078 (0x0170 - 0x00F8)
class UEnvQueryGenerator_PathingGrid final : public UEnvQueryGenerator_SimpleGrid
{
public:
struct FAIDataProviderBoolValue PathToItem; // 0x00F8(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
TSubclassOf<class UNavigationQueryFilter> NavigationFilter; // 0x0130(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ScanRangeMultiplier; // 0x0138(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryGenerator_PathingGrid">();
}
static class UEnvQueryGenerator_PathingGrid* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryGenerator_PathingGrid>();
}
};
static_assert(alignof(UEnvQueryGenerator_PathingGrid) == 0x000008, "Wrong alignment on UEnvQueryGenerator_PathingGrid");
static_assert(sizeof(UEnvQueryGenerator_PathingGrid) == 0x000170, "Wrong size on UEnvQueryGenerator_PathingGrid");
static_assert(offsetof(UEnvQueryGenerator_PathingGrid, PathToItem) == 0x0000F8, "Member 'UEnvQueryGenerator_PathingGrid::PathToItem' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_PathingGrid, NavigationFilter) == 0x000130, "Member 'UEnvQueryGenerator_PathingGrid::NavigationFilter' has a wrong offset!");
static_assert(offsetof(UEnvQueryGenerator_PathingGrid, ScanRangeMultiplier) == 0x000138, "Member 'UEnvQueryGenerator_PathingGrid::ScanRangeMultiplier' has a wrong offset!");
// Class AIModule.EnvQueryInstanceBlueprintWrapper
// 0x0050 (0x0078 - 0x0028)
class UEnvQueryInstanceBlueprintWrapper final : public UObject
{
public:
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
int32 QueryID; // 0x0030(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_34[0x24]; // 0x0034(0x0024)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UEnvQueryItemType> ItemType; // 0x0058(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
int32 OptionIndex; // 0x0060(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_64[0x4]; // 0x0064(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
TMulticastInlineDelegate<void(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus QueryStatus)> OnQueryFinishedEvent; // 0x0068(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
public:
void SetNamedParam(class FName ParamName, float Value);
float GetItemScore(int32 ItemIndex) const;
bool GetQueryResultsAsActors(TArray<class AActor*>* ResultActors) const;
bool GetQueryResultsAsLocations(TArray<struct FVector>* ResultLocations) const;
TArray<class AActor*> GetResultsAsActors() const;
TArray<struct FVector> GetResultsAsLocations() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryInstanceBlueprintWrapper">();
}
static class UEnvQueryInstanceBlueprintWrapper* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryInstanceBlueprintWrapper>();
}
};
static_assert(alignof(UEnvQueryInstanceBlueprintWrapper) == 0x000008, "Wrong alignment on UEnvQueryInstanceBlueprintWrapper");
static_assert(sizeof(UEnvQueryInstanceBlueprintWrapper) == 0x000078, "Wrong size on UEnvQueryInstanceBlueprintWrapper");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, QueryID) == 0x000030, "Member 'UEnvQueryInstanceBlueprintWrapper::QueryID' has a wrong offset!");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, ItemType) == 0x000058, "Member 'UEnvQueryInstanceBlueprintWrapper::ItemType' has a wrong offset!");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, OptionIndex) == 0x000060, "Member 'UEnvQueryInstanceBlueprintWrapper::OptionIndex' has a wrong offset!");
static_assert(offsetof(UEnvQueryInstanceBlueprintWrapper, OnQueryFinishedEvent) == 0x000068, "Member 'UEnvQueryInstanceBlueprintWrapper::OnQueryFinishedEvent' has a wrong offset!");
// Class AIModule.EnvQueryItemType_ActorBase
// 0x0000 (0x0030 - 0x0030)
class UEnvQueryItemType_ActorBase : public UEnvQueryItemType_VectorBase
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryItemType_ActorBase">();
}
static class UEnvQueryItemType_ActorBase* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryItemType_ActorBase>();
}
};
static_assert(alignof(UEnvQueryItemType_ActorBase) == 0x000008, "Wrong alignment on UEnvQueryItemType_ActorBase");
static_assert(sizeof(UEnvQueryItemType_ActorBase) == 0x000030, "Wrong size on UEnvQueryItemType_ActorBase");
// Class AIModule.EnvQueryItemType_Actor
// 0x0000 (0x0030 - 0x0030)
class UEnvQueryItemType_Actor final : public UEnvQueryItemType_ActorBase
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryItemType_Actor">();
}
static class UEnvQueryItemType_Actor* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryItemType_Actor>();
}
};
static_assert(alignof(UEnvQueryItemType_Actor) == 0x000008, "Wrong alignment on UEnvQueryItemType_Actor");
static_assert(sizeof(UEnvQueryItemType_Actor) == 0x000030, "Wrong size on UEnvQueryItemType_Actor");
// Class AIModule.EnvQueryItemType_Point
// 0x0000 (0x0030 - 0x0030)
class UEnvQueryItemType_Point final : public UEnvQueryItemType_VectorBase
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryItemType_Point">();
}
static class UEnvQueryItemType_Point* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryItemType_Point>();
}
};
static_assert(alignof(UEnvQueryItemType_Point) == 0x000008, "Wrong alignment on UEnvQueryItemType_Point");
static_assert(sizeof(UEnvQueryItemType_Point) == 0x000030, "Wrong size on UEnvQueryItemType_Point");
// Class AIModule.EnvQueryOption
// 0x0018 (0x0040 - 0x0028)
class UEnvQueryOption final : public UObject
{
public:
class UEnvQueryGenerator* Generator; // 0x0028(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<class UEnvQueryTest*> Tests; // 0x0030(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryOption">();
}
static class UEnvQueryOption* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryOption>();
}
};
static_assert(alignof(UEnvQueryOption) == 0x000008, "Wrong alignment on UEnvQueryOption");
static_assert(sizeof(UEnvQueryOption) == 0x000040, "Wrong size on UEnvQueryOption");
static_assert(offsetof(UEnvQueryOption, Generator) == 0x000028, "Member 'UEnvQueryOption::Generator' has a wrong offset!");
static_assert(offsetof(UEnvQueryOption, Tests) == 0x000030, "Member 'UEnvQueryOption::Tests' has a wrong offset!");
// Class AIModule.EnvQueryTest_Distance
// 0x0010 (0x0208 - 0x01F8)
class UEnvQueryTest_Distance final : public UEnvQueryTest
{
public:
EEnvTestDistance TestMode; // 0x01F8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_1F9[0x7]; // 0x01F9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
TSubclassOf<class UEnvQueryContext> DistanceTo; // 0x0200(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Distance">();
}
static class UEnvQueryTest_Distance* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Distance>();
}
};
static_assert(alignof(UEnvQueryTest_Distance) == 0x000008, "Wrong alignment on UEnvQueryTest_Distance");
static_assert(sizeof(UEnvQueryTest_Distance) == 0x000208, "Wrong size on UEnvQueryTest_Distance");
static_assert(offsetof(UEnvQueryTest_Distance, TestMode) == 0x0001F8, "Member 'UEnvQueryTest_Distance::TestMode' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Distance, DistanceTo) == 0x000200, "Member 'UEnvQueryTest_Distance::DistanceTo' has a wrong offset!");
// Class AIModule.EnvQueryTest_Dot
// 0x0048 (0x0240 - 0x01F8)
class UEnvQueryTest_Dot final : public UEnvQueryTest
{
public:
struct FEnvDirection lineA; // 0x01F8(0x0020)(Edit, DisableEditOnInstance, NoDestructor, Protected, NativeAccessSpecifierProtected)
struct FEnvDirection lineB; // 0x0218(0x0020)(Edit, DisableEditOnInstance, NoDestructor, Protected, NativeAccessSpecifierProtected)
EEnvTestDot TestMode; // 0x0238(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
bool bAbsoluteValue; // 0x0239(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_23A[0x6]; // 0x023A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Dot">();
}
static class UEnvQueryTest_Dot* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Dot>();
}
};
static_assert(alignof(UEnvQueryTest_Dot) == 0x000008, "Wrong alignment on UEnvQueryTest_Dot");
static_assert(sizeof(UEnvQueryTest_Dot) == 0x000240, "Wrong size on UEnvQueryTest_Dot");
static_assert(offsetof(UEnvQueryTest_Dot, lineA) == 0x0001F8, "Member 'UEnvQueryTest_Dot::lineA' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Dot, lineB) == 0x000218, "Member 'UEnvQueryTest_Dot::lineB' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Dot, TestMode) == 0x000238, "Member 'UEnvQueryTest_Dot::TestMode' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Dot, bAbsoluteValue) == 0x000239, "Member 'UEnvQueryTest_Dot::bAbsoluteValue' has a wrong offset!");
// Class AIModule.EnvQueryTest_GameplayTags
// 0x0070 (0x0268 - 0x01F8)
class UEnvQueryTest_GameplayTags final : public UEnvQueryTest
{
public:
struct FGameplayTagQuery TagQueryToMatch; // 0x01F8(0x0048)(Edit, Protected, NativeAccessSpecifierProtected)
bool bUpdatedToUseQuery; // 0x0240(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
EGameplayContainerMatchType TagsToMatch; // 0x0241(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_242[0x6]; // 0x0242(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
struct FGameplayTagContainer GameplayTags; // 0x0248(0x0020)(Protected, NativeAccessSpecifierProtected)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_GameplayTags">();
}
static class UEnvQueryTest_GameplayTags* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_GameplayTags>();
}
};
static_assert(alignof(UEnvQueryTest_GameplayTags) == 0x000008, "Wrong alignment on UEnvQueryTest_GameplayTags");
static_assert(sizeof(UEnvQueryTest_GameplayTags) == 0x000268, "Wrong size on UEnvQueryTest_GameplayTags");
static_assert(offsetof(UEnvQueryTest_GameplayTags, TagQueryToMatch) == 0x0001F8, "Member 'UEnvQueryTest_GameplayTags::TagQueryToMatch' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_GameplayTags, bUpdatedToUseQuery) == 0x000240, "Member 'UEnvQueryTest_GameplayTags::bUpdatedToUseQuery' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_GameplayTags, TagsToMatch) == 0x000241, "Member 'UEnvQueryTest_GameplayTags::TagsToMatch' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_GameplayTags, GameplayTags) == 0x000248, "Member 'UEnvQueryTest_GameplayTags::GameplayTags' has a wrong offset!");
// Class AIModule.EnvQueryTest_Overlap
// 0x0020 (0x0218 - 0x01F8)
class UEnvQueryTest_Overlap final : public UEnvQueryTest
{
public:
struct FEnvOverlapData OverlapData; // 0x01F8(0x0020)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Overlap">();
}
static class UEnvQueryTest_Overlap* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Overlap>();
}
};
static_assert(alignof(UEnvQueryTest_Overlap) == 0x000008, "Wrong alignment on UEnvQueryTest_Overlap");
static_assert(sizeof(UEnvQueryTest_Overlap) == 0x000218, "Wrong size on UEnvQueryTest_Overlap");
static_assert(offsetof(UEnvQueryTest_Overlap, OverlapData) == 0x0001F8, "Member 'UEnvQueryTest_Overlap::OverlapData' has a wrong offset!");
// Class AIModule.EnvQueryTest_PathfindingBatch
// 0x0038 (0x02B8 - 0x0280)
class UEnvQueryTest_PathfindingBatch final : public UEnvQueryTest_Pathfinding
{
public:
struct FAIDataProviderFloatValue ScanRangeMultiplier; // 0x0280(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_PathfindingBatch">();
}
static class UEnvQueryTest_PathfindingBatch* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_PathfindingBatch>();
}
};
static_assert(alignof(UEnvQueryTest_PathfindingBatch) == 0x000008, "Wrong alignment on UEnvQueryTest_PathfindingBatch");
static_assert(sizeof(UEnvQueryTest_PathfindingBatch) == 0x0002B8, "Wrong size on UEnvQueryTest_PathfindingBatch");
static_assert(offsetof(UEnvQueryTest_PathfindingBatch, ScanRangeMultiplier) == 0x000280, "Member 'UEnvQueryTest_PathfindingBatch::ScanRangeMultiplier' has a wrong offset!");
// Class AIModule.EnvQueryTest_Random
// 0x0000 (0x01F8 - 0x01F8)
class UEnvQueryTest_Random final : public UEnvQueryTest
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Random">();
}
static class UEnvQueryTest_Random* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Random>();
}
};
static_assert(alignof(UEnvQueryTest_Random) == 0x000008, "Wrong alignment on UEnvQueryTest_Random");
static_assert(sizeof(UEnvQueryTest_Random) == 0x0001F8, "Wrong size on UEnvQueryTest_Random");
// Class AIModule.EnvQueryTest_Trace
// 0x00E0 (0x02D8 - 0x01F8)
class UEnvQueryTest_Trace final : public UEnvQueryTest
{
public:
struct FEnvTraceData TraceData; // 0x01F8(0x0030)(Edit, DisableEditOnInstance, NoDestructor, NativeAccessSpecifierPublic)
struct FAIDataProviderBoolValue TraceFromContext; // 0x0228(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ItemHeightOffset; // 0x0260(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
struct FAIDataProviderFloatValue ContextHeightOffset; // 0x0298(0x0038)(Edit, DisableEditOnInstance, ContainsInstancedReference, AdvancedDisplay, NativeAccessSpecifierPublic)
TSubclassOf<class UEnvQueryContext> Context; // 0x02D0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Trace">();
}
static class UEnvQueryTest_Trace* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Trace>();
}
};
static_assert(alignof(UEnvQueryTest_Trace) == 0x000008, "Wrong alignment on UEnvQueryTest_Trace");
static_assert(sizeof(UEnvQueryTest_Trace) == 0x0002D8, "Wrong size on UEnvQueryTest_Trace");
static_assert(offsetof(UEnvQueryTest_Trace, TraceData) == 0x0001F8, "Member 'UEnvQueryTest_Trace::TraceData' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, TraceFromContext) == 0x000228, "Member 'UEnvQueryTest_Trace::TraceFromContext' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, ItemHeightOffset) == 0x000260, "Member 'UEnvQueryTest_Trace::ItemHeightOffset' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, ContextHeightOffset) == 0x000298, "Member 'UEnvQueryTest_Trace::ContextHeightOffset' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Trace, Context) == 0x0002D0, "Member 'UEnvQueryTest_Trace::Context' has a wrong offset!");
// Class AIModule.EnvQueryTest_Volume
// 0x0018 (0x0210 - 0x01F8)
class UEnvQueryTest_Volume final : public UEnvQueryTest
{
public:
TSubclassOf<class UEnvQueryContext> VolumeContext; // 0x01F8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
TSubclassOf<class AVolume> VolumeClass; // 0x0200(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
uint8 bDoComplexVolumeTest : 1; // 0x0208(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
uint8 Pad_209[0x7]; // 0x0209(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTest_Volume">();
}
static class UEnvQueryTest_Volume* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTest_Volume>();
}
};
static_assert(alignof(UEnvQueryTest_Volume) == 0x000008, "Wrong alignment on UEnvQueryTest_Volume");
static_assert(sizeof(UEnvQueryTest_Volume) == 0x000210, "Wrong size on UEnvQueryTest_Volume");
static_assert(offsetof(UEnvQueryTest_Volume, VolumeContext) == 0x0001F8, "Member 'UEnvQueryTest_Volume::VolumeContext' has a wrong offset!");
static_assert(offsetof(UEnvQueryTest_Volume, VolumeClass) == 0x000200, "Member 'UEnvQueryTest_Volume::VolumeClass' has a wrong offset!");
// Class AIModule.EnvQueryTypes
// 0x0000 (0x0028 - 0x0028)
class UEnvQueryTypes final : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EnvQueryTypes">();
}
static class UEnvQueryTypes* GetDefaultObj()
{
return GetDefaultObjImpl<UEnvQueryTypes>();
}
};
static_assert(alignof(UEnvQueryTypes) == 0x000008, "Wrong alignment on UEnvQueryTypes");
static_assert(sizeof(UEnvQueryTypes) == 0x000028, "Wrong size on UEnvQueryTypes");
// Class AIModule.EQSQueryResultSourceInterface
// 0x0000 (0x0000 - 0x0000)
class IEQSQueryResultSourceInterface final
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EQSQueryResultSourceInterface">();
}
static class IEQSQueryResultSourceInterface* GetDefaultObj()
{
return GetDefaultObjImpl<IEQSQueryResultSourceInterface>();
}
class UObject* AsUObject()
{
return reinterpret_cast<UObject*>(this);
}
const class UObject* AsUObject() const
{
return reinterpret_cast<const UObject*>(this);
}
};
static_assert(alignof(IEQSQueryResultSourceInterface) == 0x000001, "Wrong alignment on IEQSQueryResultSourceInterface");
static_assert(sizeof(IEQSQueryResultSourceInterface) == 0x000001, "Wrong size on IEQSQueryResultSourceInterface");
// Class AIModule.EQSRenderingComponent
// 0x0040 (0x0490 - 0x0450)
class UEQSRenderingComponent final : public UPrimitiveComponent
{
public:
uint8 Pad_450[0x40]; // 0x0450(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EQSRenderingComponent">();
}
static class UEQSRenderingComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UEQSRenderingComponent>();
}
};
static_assert(alignof(UEQSRenderingComponent) == 0x000010, "Wrong alignment on UEQSRenderingComponent");
static_assert(sizeof(UEQSRenderingComponent) == 0x000490, "Wrong size on UEQSRenderingComponent");
// Class AIModule.EQSTestingPawn
// 0x0090 (0x0550 - 0x04C0)
class AEQSTestingPawn final : public ACharacter
{
public:
uint8 Pad_4B8[0x8]; // 0x04B8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
class UEnvQuery* QueryTemplate; // 0x04C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
TArray<struct FEnvNamedValue> QueryParams; // 0x04C8(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
TArray<struct FAIDynamicParam> QueryConfig; // 0x04D8(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
float TimeLimitPerStep; // 0x04E8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
int32 StepToDebugDraw; // 0x04EC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
EEnvQueryHightlightMode HighlightMode; // 0x04F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_4F1[0x3]; // 0x04F1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
uint8 bDrawLabels : 1; // 0x04F4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bDrawFailedItems : 1; // 0x04F4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bReRunQueryOnlyOnFinishedMove : 1; // 0x04F4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bShouldBeVisibleInGame : 1; // 0x04F4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 bTickDuringGame : 1; // 0x04F4(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
uint8 Pad_4F5[0x3]; // 0x04F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
EEnvQueryRunMode QueryingMode; // 0x04F8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_4F9[0x7]; // 0x04F9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
struct FNavAgentProperties NavAgentProperties; // 0x0500(0x0030)(Edit, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_530[0x20]; // 0x0530(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"EQSTestingPawn">();
}
static class AEQSTestingPawn* GetDefaultObj()
{
return GetDefaultObjImpl<AEQSTestingPawn>();
}
};
static_assert(alignof(AEQSTestingPawn) == 0x000010, "Wrong alignment on AEQSTestingPawn");
static_assert(sizeof(AEQSTestingPawn) == 0x000550, "Wrong size on AEQSTestingPawn");
static_assert(offsetof(AEQSTestingPawn, QueryTemplate) == 0x0004C0, "Member 'AEQSTestingPawn::QueryTemplate' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, QueryParams) == 0x0004C8, "Member 'AEQSTestingPawn::QueryParams' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, QueryConfig) == 0x0004D8, "Member 'AEQSTestingPawn::QueryConfig' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, TimeLimitPerStep) == 0x0004E8, "Member 'AEQSTestingPawn::TimeLimitPerStep' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, StepToDebugDraw) == 0x0004EC, "Member 'AEQSTestingPawn::StepToDebugDraw' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, HighlightMode) == 0x0004F0, "Member 'AEQSTestingPawn::HighlightMode' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, QueryingMode) == 0x0004F8, "Member 'AEQSTestingPawn::QueryingMode' has a wrong offset!");
static_assert(offsetof(AEQSTestingPawn, NavAgentProperties) == 0x000500, "Member 'AEQSTestingPawn::NavAgentProperties' has a wrong offset!");
// Class AIModule.GenericTeamAgentInterface
// 0x0000 (0x0000 - 0x0000)
class IGenericTeamAgentInterface final
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"GenericTeamAgentInterface">();
}
static class IGenericTeamAgentInterface* GetDefaultObj()
{
return GetDefaultObjImpl<IGenericTeamAgentInterface>();
}
class UObject* AsUObject()
{
return reinterpret_cast<UObject*>(this);
}
const class UObject* AsUObject() const
{
return reinterpret_cast<const UObject*>(this);
}
};
static_assert(alignof(IGenericTeamAgentInterface) == 0x000001, "Wrong alignment on IGenericTeamAgentInterface");
static_assert(sizeof(IGenericTeamAgentInterface) == 0x000001, "Wrong size on IGenericTeamAgentInterface");
// Class AIModule.GridPathAIController
// 0x0000 (0x0328 - 0x0328)
class AGridPathAIController final : public AAIController
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"GridPathAIController">();
}
static class AGridPathAIController* GetDefaultObj()
{
return GetDefaultObjImpl<AGridPathAIController>();
}
};
static_assert(alignof(AGridPathAIController) == 0x000008, "Wrong alignment on AGridPathAIController");
static_assert(sizeof(AGridPathAIController) == 0x000328, "Wrong size on AGridPathAIController");
// Class AIModule.GridPathFollowingComponent
// 0x0030 (0x0280 - 0x0250)
class UGridPathFollowingComponent final : public UPathFollowingComponent
{
public:
class UNavLocalGridManager* GridManager; // 0x0250(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_258[0x28]; // 0x0258(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"GridPathFollowingComponent">();
}
static class UGridPathFollowingComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UGridPathFollowingComponent>();
}
};
static_assert(alignof(UGridPathFollowingComponent) == 0x000008, "Wrong alignment on UGridPathFollowingComponent");
static_assert(sizeof(UGridPathFollowingComponent) == 0x000280, "Wrong size on UGridPathFollowingComponent");
static_assert(offsetof(UGridPathFollowingComponent, GridManager) == 0x000250, "Member 'UGridPathFollowingComponent::GridManager' has a wrong offset!");
// Class AIModule.NavFilter_AIControllerDefault
// 0x0000 (0x0048 - 0x0048)
class UNavFilter_AIControllerDefault final : public UNavigationQueryFilter
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"NavFilter_AIControllerDefault">();
}
static class UNavFilter_AIControllerDefault* GetDefaultObj()
{
return GetDefaultObjImpl<UNavFilter_AIControllerDefault>();
}
};
static_assert(alignof(UNavFilter_AIControllerDefault) == 0x000008, "Wrong alignment on UNavFilter_AIControllerDefault");
static_assert(sizeof(UNavFilter_AIControllerDefault) == 0x000048, "Wrong size on UNavFilter_AIControllerDefault");
// Class AIModule.NavLinkProxy
// 0x0050 (0x0270 - 0x0220)
class ANavLinkProxy final : public AActor
{
public:
uint8 Pad_220[0x10]; // 0x0220(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
TArray<struct FNavigationLink> PointLinks; // 0x0230(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
TArray<struct FNavigationSegmentLink> SegmentLinks; // 0x0240(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
class UNavLinkCustomComponent* SmartLinkComp; // 0x0250(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
bool bSmartLinkIsRelevant; // 0x0258(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_259[0x7]; // 0x0259(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
TMulticastInlineDelegate<void(class AActor* MovingActor, const struct FVector& DestinationPoint)> OnSmartLinkReached; // 0x0260(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
public:
void ReceiveSmartLinkReached(class AActor* Agent, const struct FVector& Destination);
void ResumePathFollowing(class AActor* Agent);
void SetSmartLinkEnabled(bool bEnabled);
bool HasMovingAgents() const;
bool IsSmartLinkEnabled() const;
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"NavLinkProxy">();
}
static class ANavLinkProxy* GetDefaultObj()
{
return GetDefaultObjImpl<ANavLinkProxy>();
}
};
static_assert(alignof(ANavLinkProxy) == 0x000008, "Wrong alignment on ANavLinkProxy");
static_assert(sizeof(ANavLinkProxy) == 0x000270, "Wrong size on ANavLinkProxy");
static_assert(offsetof(ANavLinkProxy, PointLinks) == 0x000230, "Member 'ANavLinkProxy::PointLinks' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, SegmentLinks) == 0x000240, "Member 'ANavLinkProxy::SegmentLinks' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, SmartLinkComp) == 0x000250, "Member 'ANavLinkProxy::SmartLinkComp' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, bSmartLinkIsRelevant) == 0x000258, "Member 'ANavLinkProxy::bSmartLinkIsRelevant' has a wrong offset!");
static_assert(offsetof(ANavLinkProxy, OnSmartLinkReached) == 0x000260, "Member 'ANavLinkProxy::OnSmartLinkReached' has a wrong offset!");
// Class AIModule.NavLocalGridManager
// 0x0030 (0x0058 - 0x0028)
class UNavLocalGridManager final : public UObject
{
public:
uint8 Pad_28[0x30]; // 0x0028(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static int32 AddLocalNavigationGridForBox(class UObject* WorldContextObject, const struct FVector& Location, const struct FVector& Extent, const struct FRotator& Rotation, const int32 Radius2D, const float Height, bool bRebuildGrids);
static int32 AddLocalNavigationGridForCapsule(class UObject* WorldContextObject, const struct FVector& Location, float CapsuleRadius, float CapsuleHalfHeight, const int32 Radius2D, const float Height, bool bRebuildGrids);
static int32 AddLocalNavigationGridForPoint(class UObject* WorldContextObject, const struct FVector& Location, const int32 Radius2D, const float Height, bool bRebuildGrids);
static int32 AddLocalNavigationGridForPoints(class UObject* WorldContextObject, const TArray<struct FVector>& Locations, const int32 Radius2D, const float Height, bool bRebuildGrids);
static bool FindLocalNavigationGridPath(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, TArray<struct FVector>* PathPoints);
static void RemoveLocalNavigationGrid(class UObject* WorldContextObject, int32 GridId, bool bRebuildGrids);
static bool SetLocalNavigationGridDensity(class UObject* WorldContextObject, float CellSize);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"NavLocalGridManager">();
}
static class UNavLocalGridManager* GetDefaultObj()
{
return GetDefaultObjImpl<UNavLocalGridManager>();
}
};
static_assert(alignof(UNavLocalGridManager) == 0x000008, "Wrong alignment on UNavLocalGridManager");
static_assert(sizeof(UNavLocalGridManager) == 0x000058, "Wrong size on UNavLocalGridManager");
// Class AIModule.PathFollowingManager
// 0x0000 (0x0028 - 0x0028)
class UPathFollowingManager final : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PathFollowingManager">();
}
static class UPathFollowingManager* GetDefaultObj()
{
return GetDefaultObjImpl<UPathFollowingManager>();
}
};
static_assert(alignof(UPathFollowingManager) == 0x000008, "Wrong alignment on UPathFollowingManager");
static_assert(sizeof(UPathFollowingManager) == 0x000028, "Wrong size on UPathFollowingManager");
// Class AIModule.PawnAction_Move
// 0x0050 (0x00E0 - 0x0090)
class UPawnAction_Move final : public UPawnAction
{
public:
class AActor* GoalActor; // 0x0090(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
struct FVector GoalLocation; // 0x0098(0x000C)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
float AcceptableRadius; // 0x00A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TSubclassOf<class UNavigationQueryFilter> FilterClass; // 0x00A8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 bAllowStrafe : 1; // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bFinishOnOverlap : 1; // 0x00B0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bUsePathfinding : 1; // 0x00B0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bAllowPartialPath : 1; // 0x00B0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bProjectGoalToNavigation : 1; // 0x00B0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bUpdatePathToGoal : 1; // 0x00B0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 bAbortChildActionOnPathChange : 1; // 0x00B0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
uint8 Pad_B1[0x2F]; // 0x00B1(0x002F)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnAction_Move">();
}
static class UPawnAction_Move* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnAction_Move>();
}
};
static_assert(alignof(UPawnAction_Move) == 0x000008, "Wrong alignment on UPawnAction_Move");
static_assert(sizeof(UPawnAction_Move) == 0x0000E0, "Wrong size on UPawnAction_Move");
static_assert(offsetof(UPawnAction_Move, GoalActor) == 0x000090, "Member 'UPawnAction_Move::GoalActor' has a wrong offset!");
static_assert(offsetof(UPawnAction_Move, GoalLocation) == 0x000098, "Member 'UPawnAction_Move::GoalLocation' has a wrong offset!");
static_assert(offsetof(UPawnAction_Move, AcceptableRadius) == 0x0000A4, "Member 'UPawnAction_Move::AcceptableRadius' has a wrong offset!");
static_assert(offsetof(UPawnAction_Move, FilterClass) == 0x0000A8, "Member 'UPawnAction_Move::FilterClass' has a wrong offset!");
// Class AIModule.PawnAction_Sequence
// 0x0028 (0x00B8 - 0x0090)
class UPawnAction_Sequence final : public UPawnAction
{
public:
TArray<class UPawnAction*> ActionSequence; // 0x0090(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
EPawnActionFailHandling ChildFailureHandlingMode; // 0x00A0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_A1[0x7]; // 0x00A1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
class UPawnAction* RecentActionCopy; // 0x00A8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_B0[0x8]; // 0x00B0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnAction_Sequence">();
}
static class UPawnAction_Sequence* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnAction_Sequence>();
}
};
static_assert(alignof(UPawnAction_Sequence) == 0x000008, "Wrong alignment on UPawnAction_Sequence");
static_assert(sizeof(UPawnAction_Sequence) == 0x0000B8, "Wrong size on UPawnAction_Sequence");
static_assert(offsetof(UPawnAction_Sequence, ActionSequence) == 0x000090, "Member 'UPawnAction_Sequence::ActionSequence' has a wrong offset!");
static_assert(offsetof(UPawnAction_Sequence, ChildFailureHandlingMode) == 0x0000A0, "Member 'UPawnAction_Sequence::ChildFailureHandlingMode' has a wrong offset!");
static_assert(offsetof(UPawnAction_Sequence, RecentActionCopy) == 0x0000A8, "Member 'UPawnAction_Sequence::RecentActionCopy' has a wrong offset!");
// Class AIModule.PawnAction_Wait
// 0x0010 (0x00A0 - 0x0090)
class UPawnAction_Wait final : public UPawnAction
{
public:
float TimeToWait; // 0x0090(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
uint8 Pad_94[0xC]; // 0x0094(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnAction_Wait">();
}
static class UPawnAction_Wait* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnAction_Wait>();
}
};
static_assert(alignof(UPawnAction_Wait) == 0x000008, "Wrong alignment on UPawnAction_Wait");
static_assert(sizeof(UPawnAction_Wait) == 0x0000A0, "Wrong size on UPawnAction_Wait");
static_assert(offsetof(UPawnAction_Wait, TimeToWait) == 0x000090, "Member 'UPawnAction_Wait::TimeToWait' has a wrong offset!");
// Class AIModule.PawnActionsComponent
// 0x0038 (0x00E8 - 0x00B0)
class UPawnActionsComponent final : public UActorComponent
{
public:
class APawn* ControlledPawn; // 0x00B0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
TArray<struct FPawnActionStack> ActionStacks; // 0x00B8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
TArray<struct FPawnActionEvent> ActionEvents; // 0x00C8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
class UPawnAction* CurrentAction; // 0x00D8(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
uint8 Pad_E0[0x8]; // 0x00E0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
public:
static bool K2_PerformAction(class APawn* Pawn, class UPawnAction* Action, EAIRequestPriority Priority);
EPawnActionAbortState K2_AbortAction(class UPawnAction* ActionToAbort);
EPawnActionAbortState K2_ForceAbortAction(class UPawnAction* ActionToAbort);
bool K2_PushAction(class UPawnAction* NewAction, EAIRequestPriority Priority, class UObject* Instigator);
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"PawnActionsComponent">();
}
static class UPawnActionsComponent* GetDefaultObj()
{
return GetDefaultObjImpl<UPawnActionsComponent>();
}
};
static_assert(alignof(UPawnActionsComponent) == 0x000008, "Wrong alignment on UPawnActionsComponent");
static_assert(sizeof(UPawnActionsComponent) == 0x0000E8, "Wrong size on UPawnActionsComponent");
static_assert(offsetof(UPawnActionsComponent, ControlledPawn) == 0x0000B0, "Member 'UPawnActionsComponent::ControlledPawn' has a wrong offset!");
static_assert(offsetof(UPawnActionsComponent, ActionStacks) == 0x0000B8, "Member 'UPawnActionsComponent::ActionStacks' has a wrong offset!");
static_assert(offsetof(UPawnActionsComponent, ActionEvents) == 0x0000C8, "Member 'UPawnActionsComponent::ActionEvents' has a wrong offset!");
static_assert(offsetof(UPawnActionsComponent, CurrentAction) == 0x0000D8, "Member 'UPawnActionsComponent::CurrentAction' has a wrong offset!");
// Class AIModule.VisualLoggerExtension
// 0x0000 (0x0028 - 0x0028)
class UVisualLoggerExtension final : public UObject
{
public:
static class UClass* StaticClass()
{
return StaticClassImpl<"VisualLoggerExtension">();
}
static class UVisualLoggerExtension* GetDefaultObj()
{
return GetDefaultObjImpl<UVisualLoggerExtension>();
}
};
static_assert(alignof(UVisualLoggerExtension) == 0x000008, "Wrong alignment on UVisualLoggerExtension");
static_assert(sizeof(UVisualLoggerExtension) == 0x000028, "Wrong size on UVisualLoggerExtension");
}
Reference in New Issue View Git Blame Copy Permalink