2927 lines
244 KiB
C++
2927 lines
244 KiB
C++
#pragma once
|
|
|
|
/*
|
|
* SDK generated by Dumper-7
|
|
*
|
|
* https://github.com/Encryqed/Dumper-7
|
|
*/
|
|
|
|
// Package: GameplayAbilities
|
|
|
|
#include "Basic.hpp"
|
|
|
|
#include "Engine_structs.hpp"
|
|
#include "Engine_classes.hpp"
|
|
#include "CoreUObject_structs.hpp"
|
|
#include "CoreUObject_classes.hpp"
|
|
#include "GameplayTasks_classes.hpp"
|
|
#include "GameplayAbilities_structs.hpp"
|
|
#include "GameplayTags_structs.hpp"
|
|
#include "MovieScene_classes.hpp"
|
|
|
|
|
|
namespace SDK
|
|
{
|
|
|
|
// Class GameplayAbilities.GameplayAbilityBlueprint
|
|
// 0x0000 (0x00A0 - 0x00A0)
|
|
class UGameplayAbilityBlueprint final : public UBlueprint
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityBlueprint">();
|
|
}
|
|
static class UGameplayAbilityBlueprint* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayAbilityBlueprint>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayAbilityBlueprint) == 0x000008, "Wrong alignment on UGameplayAbilityBlueprint");
|
|
static_assert(sizeof(UGameplayAbilityBlueprint) == 0x0000A0, "Wrong size on UGameplayAbilityBlueprint");
|
|
|
|
// Class GameplayAbilities.AbilityAsync
|
|
// 0x0008 (0x0038 - 0x0030)
|
|
class UAbilityAsync : public UBlueprintAsyncActionBase
|
|
{
|
|
public:
|
|
uint8 Pad_30[0x8]; // 0x0030(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void EndAction();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityAsync">();
|
|
}
|
|
static class UAbilityAsync* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityAsync>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityAsync) == 0x000008, "Wrong alignment on UAbilityAsync");
|
|
static_assert(sizeof(UAbilityAsync) == 0x000038, "Wrong size on UAbilityAsync");
|
|
|
|
// Class GameplayAbilities.AbilitySystemComponent
|
|
// 0x11E8 (0x1308 - 0x0120)
|
|
class UAbilitySystemComponent : public UGameplayTasksComponent
|
|
{
|
|
public:
|
|
uint8 Pad_120[0x10]; // 0x0120(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<struct FAttributeDefaults> DefaultStartingData; // 0x0130(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
TArray<class UAttributeSet*> SpawnedAttributes; // 0x0140(0x0010)(ExportObject, Net, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
class FName AffectedAnimInstanceTag; // 0x0150(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_158[0x198]; // 0x0158(0x0198)(Fixing Size After Last Property [ Dumper-7 ])
|
|
float OutgoingDuration; // 0x02F0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float IncomingDuration; // 0x02F4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_2F8[0x20]; // 0x02F8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<class FString> ClientDebugStrings; // 0x0318(0x0010)(Net, ZeroConstructor, RepNotify, NativeAccessSpecifierPublic)
|
|
TArray<class FString> ServerDebugStrings; // 0x0328(0x0010)(Net, ZeroConstructor, RepNotify, NativeAccessSpecifierPublic)
|
|
uint8 Pad_338[0x58]; // 0x0338(0x0058)(Fixing Size After Last Property [ Dumper-7 ])
|
|
bool UserAbilityActivationInhibited; // 0x0390(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool ReplicationProxyEnabled; // 0x0391(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bSuppressGrantAbility; // 0x0392(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bSuppressGameplayCues; // 0x0393(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_394[0x4]; // 0x0394(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<class AGameplayAbilityTargetActor*> SpawnedTargetActors; // 0x0398(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
|
|
uint8 Pad_3A8[0x28]; // 0x03A8(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class AActor* OwnerActor; // 0x03D0(0x0008)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class AActor* AvatarActor; // 0x03D8(0x0008)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_3E0[0x10]; // 0x03E0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayAbilitySpecContainer ActivatableAbilities; // 0x03F0(0x0120)(BlueprintVisible, BlueprintReadOnly, Net, RepNotify, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_510[0x30]; // 0x0510(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<class UGameplayAbility*> AllReplicatedInstancedAbilities; // 0x0540(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_550[0x200]; // 0x0550(0x0200)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayAbilityRepAnimMontage RepAnimMontageInfo; // 0x0750(0x0030)(Net, RepNotify, NoDestructor, Protected, NativeAccessSpecifierProtected)
|
|
bool bCachedIsNetSimulated; // 0x0780(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bPendingMontageRep; // 0x0781(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_782[0x6]; // 0x0782(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayAbilityLocalAnimMontage LocalAnimMontageInfo; // 0x0788(0x0028)(NoDestructor, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_7B0[0xA0]; // 0x07B0(0x00A0)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FActiveGameplayEffectsContainer ActiveGameplayEffects; // 0x0850(0x0478)(Net, Protected, NativeAccessSpecifierProtected)
|
|
struct FActiveGameplayCueContainer ActiveGameplayCues; // 0x0CC8(0x0128)(Net, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
|
|
struct FActiveGameplayCueContainer MinimalReplicationGameplayCues; // 0x0DF0(0x0128)(Net, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_F18[0x128]; // 0x0F18(0x0128)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<uint8> BlockedAbilityBindings; // 0x1040(0x0010)(Net, ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_1050[0x128]; // 0x1050(0x0128)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FMinimalReplicationTagCountMap MinimalReplicationTags; // 0x1178(0x0060)(Net, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_11D8[0x18]; // 0x11D8(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FReplicatedPredictionKeyMap ReplicatedPredictionKeyMap; // 0x11F0(0x0118)(Net, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectSpecToSelf(const struct FGameplayEffectSpecHandle& SpecHandle);
|
|
struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectSpecToTarget(const struct FGameplayEffectSpecHandle& SpecHandle, class UAbilitySystemComponent* Target);
|
|
struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectToSelf(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level, const struct FGameplayEffectContextHandle& EffectContext);
|
|
struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectToTarget(TSubclassOf<class UGameplayEffect> GameplayEffectClass, class UAbilitySystemComponent* Target, float Level, const struct FGameplayEffectContextHandle& Context);
|
|
void ClientActivateAbilityFailed(const struct FGameplayAbilitySpecHandle& AbilityToActivate, int16 PredictionKey);
|
|
void ClientActivateAbilitySucceed(const struct FGameplayAbilitySpecHandle& AbilityToActivate, const struct FPredictionKey& PredictionKey);
|
|
void ClientActivateAbilitySucceedWithEventData(const struct FGameplayAbilitySpecHandle& AbilityToActivate, const struct FPredictionKey& PredictionKey, const struct FGameplayEventData& TriggerEventData);
|
|
void ClientCancelAbility(const struct FGameplayAbilitySpecHandle& AbilityToCancel, const struct FGameplayAbilityActivationInfo& ActivationInfo);
|
|
void ClientEndAbility(const struct FGameplayAbilitySpecHandle& AbilityToEnd, const struct FGameplayAbilityActivationInfo& ActivationInfo);
|
|
void ClientPrintDebug_Response(const TArray<class FString>& Strings, int32 GameFlags);
|
|
void ClientSetReplicatedEvent(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey);
|
|
void ClientTryActivateAbility(const struct FGameplayAbilitySpecHandle& AbilityToActivate);
|
|
int32 GetGameplayEffectCount(TSubclassOf<class UGameplayEffect> SourceGameplayEffect, class UAbilitySystemComponent* OptionalInstigatorFilterComponent, bool bEnforceOnGoingCheck);
|
|
void K2_InitStats(TSubclassOf<class UAttributeSet> Attributes, const class UDataTable* DataTable);
|
|
void NetMulticast_InvokeGameplayCueAdded(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext);
|
|
void NetMulticast_InvokeGameplayCueAdded_WithParams(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& Parameters);
|
|
void NetMulticast_InvokeGameplayCueAddedAndWhileActive_FromSpec(const struct FGameplayEffectSpecForRPC& Spec, const struct FPredictionKey& PredictionKey);
|
|
void NetMulticast_InvokeGameplayCueAddedAndWhileActive_WithParams(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
|
|
void NetMulticast_InvokeGameplayCueExecuted(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext);
|
|
void NetMulticast_InvokeGameplayCueExecuted_FromSpec(const struct FGameplayEffectSpecForRPC& Spec, const struct FPredictionKey& PredictionKey);
|
|
void NetMulticast_InvokeGameplayCueExecuted_WithParams(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
|
|
void NetMulticast_InvokeGameplayCuesAddedAndWhileActive_WithParams(const struct FGameplayTagContainer& GameplayCueTags, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
|
|
void NetMulticast_InvokeGameplayCuesExecuted(const struct FGameplayTagContainer& GameplayCueTags, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext);
|
|
void NetMulticast_InvokeGameplayCuesExecuted_WithParams(const struct FGameplayTagContainer& GameplayCueTags, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
|
|
void OnRep_ActivateAbilities();
|
|
void OnRep_ClientDebugString();
|
|
void OnRep_OwningActor();
|
|
void OnRep_ReplicatedAnimMontage();
|
|
void OnRep_ServerDebugString();
|
|
int32 RemoveActiveEffectsWithAppliedTags(const struct FGameplayTagContainer& Tags);
|
|
int32 RemoveActiveEffectsWithGrantedTags(const struct FGameplayTagContainer& Tags);
|
|
int32 RemoveActiveEffectsWithSourceTags(const struct FGameplayTagContainer& Tags);
|
|
int32 RemoveActiveEffectsWithTags(const struct FGameplayTagContainer& Tags);
|
|
bool RemoveActiveGameplayEffect(const struct FActiveGameplayEffectHandle& Handle, int32 StacksToRemove);
|
|
void RemoveActiveGameplayEffectBySourceEffect(TSubclassOf<class UGameplayEffect> GameplayEffect, class UAbilitySystemComponent* InstigatorAbilitySystemComponent, int32 StacksToRemove);
|
|
void ServerAbilityRPCBatch(const struct GameplayAbilities::FServerAbilityRPCBatch& BatchInfo);
|
|
void ServerCancelAbility(const struct FGameplayAbilitySpecHandle& AbilityToCancel, const struct FGameplayAbilityActivationInfo& ActivationInfo);
|
|
void ServerCurrentMontageJumpToSectionName(class UAnimMontage* ClientAnimMontage, class FName SectionName);
|
|
void ServerCurrentMontageSetNextSectionName(class UAnimMontage* ClientAnimMontage, float ClientPosition, class FName SectionName, class FName NextSectionName);
|
|
void ServerCurrentMontageSetPlayRate(class UAnimMontage* ClientAnimMontage, float InPlayRate);
|
|
void ServerEndAbility(const struct FGameplayAbilitySpecHandle& AbilityToEnd, const struct FGameplayAbilityActivationInfo& ActivationInfo, const struct FPredictionKey& PredictionKey);
|
|
void ServerPrintDebug_Request();
|
|
void ServerPrintDebug_RequestWithStrings(const TArray<class FString>& Strings);
|
|
void ServerSetInputPressed(const struct FGameplayAbilitySpecHandle& AbilityHandle);
|
|
void ServerSetInputReleased(const struct FGameplayAbilitySpecHandle& AbilityHandle);
|
|
void ServerSetReplicatedEvent(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey);
|
|
void ServerSetReplicatedEventWithPayload(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey, const struct FVector_NetQuantize100& VectorPayload);
|
|
void ServerSetReplicatedTargetData(const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FGameplayAbilityTargetDataHandle& ReplicatedTargetDataHandle, const struct FGameplayTag& ApplicationTag, const struct FPredictionKey& CurrentPredictionKey);
|
|
void ServerSetReplicatedTargetDataCancelled(const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey);
|
|
void ServerTryActivateAbility(const struct FGameplayAbilitySpecHandle& AbilityToActivate, bool InputPressed, const struct FPredictionKey& PredictionKey);
|
|
void ServerTryActivateAbilityWithEventData(const struct FGameplayAbilitySpecHandle& AbilityToActivate, bool InputPressed, const struct FPredictionKey& PredictionKey, const struct FGameplayEventData& TriggerEventData);
|
|
void SetActiveGameplayEffectLevel(const struct FActiveGameplayEffectHandle& ActiveHandle, int32 NewLevel);
|
|
void SetActiveGameplayEffectLevelUsingQuery(const struct FGameplayEffectQuery& Query, int32 NewLevel);
|
|
void SetUserAbilityActivationInhibited(bool NewInhibit);
|
|
void TargetCancel();
|
|
void TargetConfirm();
|
|
bool TryActivateAbilitiesByTag(const struct FGameplayTagContainer& GameplayTagContainer, bool bAllowRemoteActivation);
|
|
bool TryActivateAbilityByClass(TSubclassOf<class UGameplayAbility> InAbilityToActivate, bool bAllowRemoteActivation);
|
|
|
|
TArray<struct FActiveGameplayEffectHandle> GetActiveEffects(const struct FGameplayEffectQuery& Query) const;
|
|
TArray<struct FActiveGameplayEffectHandle> GetActiveEffectsWithAllTags(const struct FGameplayTagContainer& Tags) const;
|
|
float GetGameplayEffectMagnitude(const struct FActiveGameplayEffectHandle& Handle, const struct FGameplayAttribute& Attribute) const;
|
|
bool GetUserAbilityActivationInhibited() const;
|
|
bool IsGameplayCueActive(const struct FGameplayTag& GameplayCueTag) const;
|
|
struct FGameplayEffectContextHandle MakeEffectContext() const;
|
|
struct FGameplayEffectSpecHandle MakeOutgoingSpec(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level, const struct FGameplayEffectContextHandle& Context) const;
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemComponent">();
|
|
}
|
|
static class UAbilitySystemComponent* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilitySystemComponent>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilitySystemComponent) == 0x000008, "Wrong alignment on UAbilitySystemComponent");
|
|
static_assert(sizeof(UAbilitySystemComponent) == 0x001308, "Wrong size on UAbilitySystemComponent");
|
|
static_assert(offsetof(UAbilitySystemComponent, DefaultStartingData) == 0x000130, "Member 'UAbilitySystemComponent::DefaultStartingData' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, SpawnedAttributes) == 0x000140, "Member 'UAbilitySystemComponent::SpawnedAttributes' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, AffectedAnimInstanceTag) == 0x000150, "Member 'UAbilitySystemComponent::AffectedAnimInstanceTag' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, OutgoingDuration) == 0x0002F0, "Member 'UAbilitySystemComponent::OutgoingDuration' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, IncomingDuration) == 0x0002F4, "Member 'UAbilitySystemComponent::IncomingDuration' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, ClientDebugStrings) == 0x000318, "Member 'UAbilitySystemComponent::ClientDebugStrings' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, ServerDebugStrings) == 0x000328, "Member 'UAbilitySystemComponent::ServerDebugStrings' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, UserAbilityActivationInhibited) == 0x000390, "Member 'UAbilitySystemComponent::UserAbilityActivationInhibited' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, ReplicationProxyEnabled) == 0x000391, "Member 'UAbilitySystemComponent::ReplicationProxyEnabled' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, bSuppressGrantAbility) == 0x000392, "Member 'UAbilitySystemComponent::bSuppressGrantAbility' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, bSuppressGameplayCues) == 0x000393, "Member 'UAbilitySystemComponent::bSuppressGameplayCues' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, SpawnedTargetActors) == 0x000398, "Member 'UAbilitySystemComponent::SpawnedTargetActors' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, OwnerActor) == 0x0003D0, "Member 'UAbilitySystemComponent::OwnerActor' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, AvatarActor) == 0x0003D8, "Member 'UAbilitySystemComponent::AvatarActor' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, ActivatableAbilities) == 0x0003F0, "Member 'UAbilitySystemComponent::ActivatableAbilities' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, AllReplicatedInstancedAbilities) == 0x000540, "Member 'UAbilitySystemComponent::AllReplicatedInstancedAbilities' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, RepAnimMontageInfo) == 0x000750, "Member 'UAbilitySystemComponent::RepAnimMontageInfo' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, bCachedIsNetSimulated) == 0x000780, "Member 'UAbilitySystemComponent::bCachedIsNetSimulated' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, bPendingMontageRep) == 0x000781, "Member 'UAbilitySystemComponent::bPendingMontageRep' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, LocalAnimMontageInfo) == 0x000788, "Member 'UAbilitySystemComponent::LocalAnimMontageInfo' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, ActiveGameplayEffects) == 0x000850, "Member 'UAbilitySystemComponent::ActiveGameplayEffects' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, ActiveGameplayCues) == 0x000CC8, "Member 'UAbilitySystemComponent::ActiveGameplayCues' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, MinimalReplicationGameplayCues) == 0x000DF0, "Member 'UAbilitySystemComponent::MinimalReplicationGameplayCues' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, BlockedAbilityBindings) == 0x001040, "Member 'UAbilitySystemComponent::BlockedAbilityBindings' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, MinimalReplicationTags) == 0x001178, "Member 'UAbilitySystemComponent::MinimalReplicationTags' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemComponent, ReplicatedPredictionKeyMap) == 0x0011F0, "Member 'UAbilitySystemComponent::ReplicatedPredictionKeyMap' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbilitySet
|
|
// 0x0010 (0x0040 - 0x0030)
|
|
class UGameplayAbilitySet final : public UDataAsset
|
|
{
|
|
public:
|
|
TArray<struct FGameplayAbilityBindInfo> Abilities; // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilitySet">();
|
|
}
|
|
static class UGameplayAbilitySet* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayAbilitySet>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayAbilitySet) == 0x000008, "Wrong alignment on UGameplayAbilitySet");
|
|
static_assert(sizeof(UGameplayAbilitySet) == 0x000040, "Wrong size on UGameplayAbilitySet");
|
|
static_assert(offsetof(UGameplayAbilitySet, Abilities) == 0x000030, "Member 'UGameplayAbilitySet::Abilities' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityAsync_WaitGameplayEffectApplied
|
|
// 0x00C0 (0x00F8 - 0x0038)
|
|
class UAbilityAsync_WaitGameplayEffectApplied final : public UAbilityAsync
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(class AActor* Source, const struct FGameplayEffectSpecHandle& SpecHandle, const struct FActiveGameplayEffectHandle& ActiveHandle)> OnApplied; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_48[0xB0]; // 0x0048(0x00B0)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityAsync_WaitGameplayEffectApplied* WaitGameplayEffectAppliedToActor(class AActor* TargetActor, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, bool ListenForPeriodicEffect);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityAsync_WaitGameplayEffectApplied">();
|
|
}
|
|
static class UAbilityAsync_WaitGameplayEffectApplied* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityAsync_WaitGameplayEffectApplied>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityAsync_WaitGameplayEffectApplied) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayEffectApplied");
|
|
static_assert(sizeof(UAbilityAsync_WaitGameplayEffectApplied) == 0x0000F8, "Wrong size on UAbilityAsync_WaitGameplayEffectApplied");
|
|
static_assert(offsetof(UAbilityAsync_WaitGameplayEffectApplied, OnApplied) == 0x000038, "Member 'UAbilityAsync_WaitGameplayEffectApplied::OnApplied' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityTargetActor
|
|
// 0x0120 (0x0340 - 0x0220)
|
|
#pragma pack(push, 0x1)
|
|
class alignas(0x10) AGameplayAbilityTargetActor : public AActor
|
|
{
|
|
public:
|
|
bool ShouldProduceTargetDataOnServer; // 0x0220(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_221[0xF]; // 0x0221(0x000F)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayAbilityTargetingLocationInfo StartLocation; // 0x0230(0x0070)(BlueprintVisible, BlueprintReadOnly, Net, ContainsInstancedReference, ExposeOnSpawn, NativeAccessSpecifierPublic)
|
|
uint8 Pad_2A0[0x30]; // 0x02A0(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class APlayerController* MasterPC; // 0x02D0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class UGameplayAbility* OwningAbility; // 0x02D8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bDestroyOnConfirmation; // 0x02E0(0x0001)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_2E1[0x7]; // 0x02E1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class AActor* SourceActor; // 0x02E8(0x0008)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FWorldReticleParameters ReticleParams; // 0x02F0(0x000C)(BlueprintVisible, NoDestructor, ExposeOnSpawn, NativeAccessSpecifierPublic)
|
|
uint8 Pad_2FC[0x4]; // 0x02FC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TSubclassOf<class AGameplayAbilityWorldReticle> ReticleClass; // 0x0300(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FGameplayTargetDataFilterHandle Filter; // 0x0308(0x0010)(BlueprintVisible, Net, ExposeOnSpawn, NativeAccessSpecifierPublic)
|
|
bool bDebug; // 0x0318(0x0001)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_319[0x17]; // 0x0319(0x0017)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* GenericDelegateBoundASC; // 0x0330(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
void CancelTargeting();
|
|
void ConfirmTargeting();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityTargetActor">();
|
|
}
|
|
static class AGameplayAbilityTargetActor* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityTargetActor>();
|
|
}
|
|
};
|
|
#pragma pack(pop)
|
|
static_assert(alignof(AGameplayAbilityTargetActor) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor");
|
|
static_assert(sizeof(AGameplayAbilityTargetActor) == 0x000340, "Wrong size on AGameplayAbilityTargetActor");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, ShouldProduceTargetDataOnServer) == 0x000220, "Member 'AGameplayAbilityTargetActor::ShouldProduceTargetDataOnServer' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, StartLocation) == 0x000230, "Member 'AGameplayAbilityTargetActor::StartLocation' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, MasterPC) == 0x0002D0, "Member 'AGameplayAbilityTargetActor::MasterPC' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, OwningAbility) == 0x0002D8, "Member 'AGameplayAbilityTargetActor::OwningAbility' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, bDestroyOnConfirmation) == 0x0002E0, "Member 'AGameplayAbilityTargetActor::bDestroyOnConfirmation' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, SourceActor) == 0x0002E8, "Member 'AGameplayAbilityTargetActor::SourceActor' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, ReticleParams) == 0x0002F0, "Member 'AGameplayAbilityTargetActor::ReticleParams' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, ReticleClass) == 0x000300, "Member 'AGameplayAbilityTargetActor::ReticleClass' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, Filter) == 0x000308, "Member 'AGameplayAbilityTargetActor::Filter' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, bDebug) == 0x000318, "Member 'AGameplayAbilityTargetActor::bDebug' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor, GenericDelegateBoundASC) == 0x000330, "Member 'AGameplayAbilityTargetActor::GenericDelegateBoundASC' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityAsync_WaitGameplayEvent
|
|
// 0x0028 (0x0060 - 0x0038)
|
|
class UAbilityAsync_WaitGameplayEvent final : public UAbilityAsync
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(const struct FGameplayEventData& Payload)> EventReceived; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_48[0x18]; // 0x0048(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityAsync_WaitGameplayEvent* WaitGameplayEventToActor(class AActor* TargetActor, const struct FGameplayTag& EventTag, bool OnlyTriggerOnce, bool OnlyMatchExact);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityAsync_WaitGameplayEvent">();
|
|
}
|
|
static class UAbilityAsync_WaitGameplayEvent* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityAsync_WaitGameplayEvent>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityAsync_WaitGameplayEvent) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayEvent");
|
|
static_assert(sizeof(UAbilityAsync_WaitGameplayEvent) == 0x000060, "Wrong size on UAbilityAsync_WaitGameplayEvent");
|
|
static_assert(offsetof(UAbilityAsync_WaitGameplayEvent, EventReceived) == 0x000038, "Member 'UAbilityAsync_WaitGameplayEvent::EventReceived' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityTargetActor_Trace
|
|
// 0x0010 (0x0350 - 0x0340)
|
|
class AGameplayAbilityTargetActor_Trace : public AGameplayAbilityTargetActor
|
|
{
|
|
public:
|
|
float MaxRange; // 0x0338(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FCollisionProfileName TraceProfile; // 0x033C(0x0008)(Edit, BlueprintVisible, Config, NoDestructor, ExposeOnSpawn, NativeAccessSpecifierPublic)
|
|
bool bTraceAffectsAimPitch; // 0x0344(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_345[0xB]; // 0x0345(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityTargetActor_Trace">();
|
|
}
|
|
static class AGameplayAbilityTargetActor_Trace* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityTargetActor_Trace>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayAbilityTargetActor_Trace) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_Trace");
|
|
static_assert(sizeof(AGameplayAbilityTargetActor_Trace) == 0x000350, "Wrong size on AGameplayAbilityTargetActor_Trace");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_Trace, MaxRange) == 0x000338, "Member 'AGameplayAbilityTargetActor_Trace::MaxRange' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_Trace, TraceProfile) == 0x00033C, "Member 'AGameplayAbilityTargetActor_Trace::TraceProfile' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_Trace, bTraceAffectsAimPitch) == 0x000344, "Member 'AGameplayAbilityTargetActor_Trace::bTraceAffectsAimPitch' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityAsync_WaitGameplayTag
|
|
// 0x0018 (0x0050 - 0x0038)
|
|
class UAbilityAsync_WaitGameplayTag : public UAbilityAsync
|
|
{
|
|
public:
|
|
uint8 Pad_38[0x18]; // 0x0038(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityAsync_WaitGameplayTag">();
|
|
}
|
|
static class UAbilityAsync_WaitGameplayTag* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityAsync_WaitGameplayTag>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityAsync_WaitGameplayTag) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayTag");
|
|
static_assert(sizeof(UAbilityAsync_WaitGameplayTag) == 0x000050, "Wrong size on UAbilityAsync_WaitGameplayTag");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityTargetActor_GroundTrace
|
|
// 0x0020 (0x0370 - 0x0350)
|
|
class AGameplayAbilityTargetActor_GroundTrace : public AGameplayAbilityTargetActor_Trace
|
|
{
|
|
public:
|
|
float CollisionRadius; // 0x0350(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float CollisionHeight; // 0x0354(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_358[0x18]; // 0x0358(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityTargetActor_GroundTrace">();
|
|
}
|
|
static class AGameplayAbilityTargetActor_GroundTrace* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityTargetActor_GroundTrace>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayAbilityTargetActor_GroundTrace) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_GroundTrace");
|
|
static_assert(sizeof(AGameplayAbilityTargetActor_GroundTrace) == 0x000370, "Wrong size on AGameplayAbilityTargetActor_GroundTrace");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_GroundTrace, CollisionRadius) == 0x000350, "Member 'AGameplayAbilityTargetActor_GroundTrace::CollisionRadius' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_GroundTrace, CollisionHeight) == 0x000354, "Member 'AGameplayAbilityTargetActor_GroundTrace::CollisionHeight' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityAsync_WaitGameplayTagAdded
|
|
// 0x0010 (0x0060 - 0x0050)
|
|
class UAbilityAsync_WaitGameplayTagAdded final : public UAbilityAsync_WaitGameplayTag
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> Added; // 0x0050(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UAbilityAsync_WaitGameplayTagAdded* WaitGameplayTagAddToActor(class AActor* TargetActor, const struct FGameplayTag& Tag, bool OnlyTriggerOnce);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityAsync_WaitGameplayTagAdded">();
|
|
}
|
|
static class UAbilityAsync_WaitGameplayTagAdded* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityAsync_WaitGameplayTagAdded>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityAsync_WaitGameplayTagAdded) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayTagAdded");
|
|
static_assert(sizeof(UAbilityAsync_WaitGameplayTagAdded) == 0x000060, "Wrong size on UAbilityAsync_WaitGameplayTagAdded");
|
|
static_assert(offsetof(UAbilityAsync_WaitGameplayTagAdded, Added) == 0x000050, "Member 'UAbilityAsync_WaitGameplayTagAdded::Added' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityTargetActor_ActorPlacement
|
|
// 0x0020 (0x0390 - 0x0370)
|
|
class AGameplayAbilityTargetActor_ActorPlacement final : public AGameplayAbilityTargetActor_GroundTrace
|
|
{
|
|
public:
|
|
class UClass* PlacedActorClass; // 0x0370(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class UMaterialInterface* PlacedActorMaterial; // 0x0378(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_380[0x10]; // 0x0380(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityTargetActor_ActorPlacement">();
|
|
}
|
|
static class AGameplayAbilityTargetActor_ActorPlacement* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityTargetActor_ActorPlacement>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayAbilityTargetActor_ActorPlacement) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_ActorPlacement");
|
|
static_assert(sizeof(AGameplayAbilityTargetActor_ActorPlacement) == 0x000390, "Wrong size on AGameplayAbilityTargetActor_ActorPlacement");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_ActorPlacement, PlacedActorClass) == 0x000370, "Member 'AGameplayAbilityTargetActor_ActorPlacement::PlacedActorClass' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_ActorPlacement, PlacedActorMaterial) == 0x000378, "Member 'AGameplayAbilityTargetActor_ActorPlacement::PlacedActorMaterial' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityAsync_WaitGameplayTagRemoved
|
|
// 0x0010 (0x0060 - 0x0050)
|
|
class UAbilityAsync_WaitGameplayTagRemoved final : public UAbilityAsync_WaitGameplayTag
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> Removed; // 0x0050(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UAbilityAsync_WaitGameplayTagRemoved* WaitGameplayTagRemoveFromActor(class AActor* TargetActor, const struct FGameplayTag& Tag, bool OnlyTriggerOnce);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityAsync_WaitGameplayTagRemoved">();
|
|
}
|
|
static class UAbilityAsync_WaitGameplayTagRemoved* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityAsync_WaitGameplayTagRemoved>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityAsync_WaitGameplayTagRemoved) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayTagRemoved");
|
|
static_assert(sizeof(UAbilityAsync_WaitGameplayTagRemoved) == 0x000060, "Wrong size on UAbilityAsync_WaitGameplayTagRemoved");
|
|
static_assert(offsetof(UAbilityAsync_WaitGameplayTagRemoved, Removed) == 0x000050, "Member 'UAbilityAsync_WaitGameplayTagRemoved::Removed' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityTargetActor_Radius
|
|
// 0x0000 (0x0340 - 0x0340)
|
|
class AGameplayAbilityTargetActor_Radius final : public AGameplayAbilityTargetActor
|
|
{
|
|
public:
|
|
float Radius; // 0x0338(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_33C[0x4]; // 0x033C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityTargetActor_Radius">();
|
|
}
|
|
static class AGameplayAbilityTargetActor_Radius* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityTargetActor_Radius>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayAbilityTargetActor_Radius) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_Radius");
|
|
static_assert(sizeof(AGameplayAbilityTargetActor_Radius) == 0x000340, "Wrong size on AGameplayAbilityTargetActor_Radius");
|
|
static_assert(offsetof(AGameplayAbilityTargetActor_Radius, Radius) == 0x000338, "Member 'AGameplayAbilityTargetActor_Radius::Radius' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilitySystemBlueprintLibrary
|
|
// 0x0000 (0x0028 - 0x0028)
|
|
class UAbilitySystemBlueprintLibrary final : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromActor(class AActor* Actor);
|
|
static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromActorArray(const TArray<class AActor*>& ActorArray, bool OneTargetPerHandle);
|
|
static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromHitResult(const struct FHitResult& HitResult);
|
|
static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromLocations(const struct FGameplayAbilityTargetingLocationInfo& SourceLocation, const struct FGameplayAbilityTargetingLocationInfo& TargetLocation);
|
|
static struct FGameplayEffectSpecHandle AddAssetTag(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& NewGameplayTag);
|
|
static struct FGameplayEffectSpecHandle AddAssetTags(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTagContainer& NewGameplayTags);
|
|
static struct FGameplayEffectSpecHandle AddGrantedTag(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& NewGameplayTag);
|
|
static struct FGameplayEffectSpecHandle AddGrantedTags(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTagContainer& NewGameplayTags);
|
|
static struct FGameplayEffectSpecHandle AddLinkedGameplayEffect(const struct FGameplayEffectSpecHandle& SpecHandle, TSubclassOf<class UGameplayEffect> LinkedGameplayEffect);
|
|
static struct FGameplayEffectSpecHandle AddLinkedGameplayEffectSpec(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayEffectSpecHandle& LinkedGameplayEffectSpec);
|
|
static struct FGameplayAbilityTargetDataHandle AppendTargetDataHandle(const struct FGameplayAbilityTargetDataHandle& TargetHandle, const struct FGameplayAbilityTargetDataHandle& HandleToAdd);
|
|
static struct FGameplayEffectSpecHandle AssignSetByCallerMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, class FName DataName, float Magnitude);
|
|
static struct FGameplayEffectSpecHandle AssignTagSetByCallerMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& DataTag, float Magnitude);
|
|
static void BreakGameplayCueParameters(const struct FGameplayCueParameters& Parameters, float* NormalizedMagnitude, float* RawMagnitude, struct FGameplayEffectContextHandle* EffectContext, struct FGameplayTag* MatchedTagName, struct FGameplayTag* OriginalTag, struct FGameplayTagContainer* AggregatedSourceTags, struct FGameplayTagContainer* AggregatedTargetTags, struct FVector* Location, struct FVector* Normal, class AActor** Instigator, class AActor** EffectCauser, class UObject** SourceObject, class UPhysicalMaterial** PhysicalMaterial, int32* GameplayEffectLevel, int32* AbilityLevel, class USceneComponent** TargetAttachComponent, bool* bReplicateLocationWhenUsingMinimalRepProxy);
|
|
static struct FGameplayEffectSpecHandle CloneSpecHandle(class AActor* InNewInstigator, class AActor* InEffectCauser, const struct FGameplayEffectSpecHandle& GameplayEffectSpecHandle_Clone);
|
|
static bool DoesGameplayCueMeetTagRequirements(const struct FGameplayCueParameters& Parameters, const struct FGameplayTagRequirements& SourceTagReqs, const struct FGameplayTagRequirements& TargetTagReqs);
|
|
static bool DoesTargetDataContainActor(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0, class AActor* Actor);
|
|
static void EffectContextAddHitResult(const struct FGameplayEffectContextHandle& EffectContext, const struct FHitResult& HitResult, bool bReset);
|
|
static class AActor* EffectContextGetEffectCauser(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static struct FHitResult EffectContextGetHitResult(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static class AActor* EffectContextGetInstigatorActor(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static struct FVector EffectContextGetOrigin(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static class AActor* EffectContextGetOriginalInstigatorActor(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static class UObject* EffectContextGetSourceObject(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static bool EffectContextHasHitResult(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static bool EffectContextIsInstigatorLocallyControlled(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static bool EffectContextIsValid(const struct FGameplayEffectContextHandle& EffectContext);
|
|
static void EffectContextSetOrigin(const struct FGameplayEffectContextHandle& EffectContext, const struct FVector& Origin);
|
|
static bool EqualEqual_GameplayAttributeGameplayAttribute(const struct FGameplayAttribute& AttributeA, const struct FGameplayAttribute& AttributeB);
|
|
static float EvaluateAttributeValueWithTags(class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, const struct FGameplayTagContainer& SourceTags, const struct FGameplayTagContainer& TargetTags, bool* bSuccess);
|
|
static float EvaluateAttributeValueWithTagsAndBase(class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, const struct FGameplayTagContainer& SourceTags, const struct FGameplayTagContainer& TargetTags, float BaseValue, bool* bSuccess);
|
|
static struct FGameplayAbilityTargetDataHandle FilterTargetData(const struct FGameplayAbilityTargetDataHandle& TargetDataHandle, const struct FGameplayTargetDataFilterHandle& ActorFilterClass);
|
|
static void ForwardGameplayCueToTarget(TScriptInterface<class IGameplayCueInterface> TargetCueInterface, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters);
|
|
static class UAbilitySystemComponent* GetAbilitySystemComponent(class AActor* Actor);
|
|
static class FString GetActiveGameplayEffectDebugString(const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
static float GetActiveGameplayEffectExpectedEndTime(const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
static float GetActiveGameplayEffectRemainingDuration(class UObject* WorldContextObject, const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
static int32 GetActiveGameplayEffectStackCount(const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
static int32 GetActiveGameplayEffectStackLimitCount(const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
static float GetActiveGameplayEffectStartTime(const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
static float GetActiveGameplayEffectTotalDuration(const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
static class AActor* GetActorByIndex(const struct FGameplayCueParameters& Parameters, int32 Index_0);
|
|
static int32 GetActorCount(const struct FGameplayCueParameters& Parameters);
|
|
static TArray<class AActor*> GetActorsFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
|
|
static TArray<class AActor*> GetAllActorsFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData);
|
|
static TArray<struct FGameplayEffectSpecHandle> GetAllLinkedGameplayEffectSpecHandles(const struct FGameplayEffectSpecHandle& SpecHandle);
|
|
static int32 GetDataCountFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData);
|
|
static struct FGameplayEffectContextHandle GetEffectContext(const struct FGameplayEffectSpecHandle& SpecHandle);
|
|
static float GetFloatAttribute(const class AActor* Actor, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
|
|
static float GetFloatAttributeBase(const class AActor* Actor, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
|
|
static float GetFloatAttributeBaseFromAbilitySystemComponent(const class UAbilitySystemComponent* AbilitySystemComponent, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
|
|
static float GetFloatAttributeFromAbilitySystemComponent(const class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
|
|
static bool GetGameplayCueDirection(class AActor* TargetActor, const struct FGameplayCueParameters& Parameters, struct FVector* Direction);
|
|
static bool GetGameplayCueEndLocationAndNormal(class AActor* TargetActor, const struct FGameplayCueParameters& Parameters, struct FVector* Location, struct FVector* Normal);
|
|
static struct FHitResult GetHitResult(const struct FGameplayCueParameters& Parameters);
|
|
static struct FHitResult GetHitResultFromTargetData(const struct FGameplayAbilityTargetDataHandle& HitResult, int32 Index_0);
|
|
static class AActor* GetInstigatorActor(const struct FGameplayCueParameters& Parameters);
|
|
static struct FTransform GetInstigatorTransform(const struct FGameplayCueParameters& Parameters);
|
|
static float GetModifiedAttributeMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayAttribute& Attribute);
|
|
static struct FVector GetOrigin(const struct FGameplayCueParameters& Parameters);
|
|
static struct FVector GetTargetDataEndPoint(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
|
|
static struct FTransform GetTargetDataEndPointTransform(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
|
|
static struct FTransform GetTargetDataOrigin(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
|
|
static bool HasHitResult(const struct FGameplayCueParameters& Parameters);
|
|
static bool IsInstigatorLocallyControlled(const struct FGameplayCueParameters& Parameters);
|
|
static bool IsInstigatorLocallyControlledPlayer(const struct FGameplayCueParameters& Parameters);
|
|
static bool IsValid(const struct FGameplayAttribute& Attribute);
|
|
static struct FGameplayTargetDataFilterHandle MakeFilterHandle(const struct FGameplayTargetDataFilter& Filter, class AActor* FilterActor);
|
|
static struct FGameplayCueParameters MakeGameplayCueParameters(float NormalizedMagnitude, float RawMagnitude, const struct FGameplayEffectContextHandle& EffectContext, const struct FGameplayTag& MatchedTagName, const struct FGameplayTag& OriginalTag, const struct FGameplayTagContainer& AggregatedSourceTags, const struct FGameplayTagContainer& AggregatedTargetTags, const struct FVector& Location, const struct FVector& Normal, class AActor* Instigator, class AActor* EffectCauser, class UObject* SourceObject, class UPhysicalMaterial* PhysicalMaterial, int32 GameplayEffectLevel, int32 AbilityLevel, class USceneComponent* TargetAttachComponent, bool bReplicateLocationWhenUsingMinimalRepProxy);
|
|
static struct FGameplayEffectSpecHandle MakeSpecHandle(class UGameplayEffect* InGameplayEffect, class AActor* InInstigator, class AActor* InEffectCauser, float InLevel);
|
|
static bool NotEqual_GameplayAttributeGameplayAttribute(const struct FGameplayAttribute& AttributeA, const struct FGameplayAttribute& AttributeB);
|
|
static void SendGameplayEventToActor(class AActor* Actor, const struct FGameplayTag& EventTag, const struct FGameplayEventData& Payload);
|
|
static struct FGameplayEffectSpecHandle SetDuration(const struct FGameplayEffectSpecHandle& SpecHandle, float Duration);
|
|
static struct FGameplayEffectSpecHandle SetStackCount(const struct FGameplayEffectSpecHandle& SpecHandle, int32 StackCount);
|
|
static struct FGameplayEffectSpecHandle SetStackCountToMax(const struct FGameplayEffectSpecHandle& SpecHandle);
|
|
static bool TargetDataHasActor(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
|
|
static bool TargetDataHasEndPoint(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
|
|
static bool TargetDataHasHitResult(const struct FGameplayAbilityTargetDataHandle& HitResult, int32 Index_0);
|
|
static bool TargetDataHasOrigin(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemBlueprintLibrary">();
|
|
}
|
|
static class UAbilitySystemBlueprintLibrary* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilitySystemBlueprintLibrary>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilitySystemBlueprintLibrary) == 0x000008, "Wrong alignment on UAbilitySystemBlueprintLibrary");
|
|
static_assert(sizeof(UAbilitySystemBlueprintLibrary) == 0x000028, "Wrong size on UAbilitySystemBlueprintLibrary");
|
|
|
|
// Class GameplayAbilities.AbilitySystemDebugHUD
|
|
// 0x0000 (0x0310 - 0x0310)
|
|
class AAbilitySystemDebugHUD final : public AHUD
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemDebugHUD">();
|
|
}
|
|
static class AAbilitySystemDebugHUD* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AAbilitySystemDebugHUD>();
|
|
}
|
|
};
|
|
static_assert(alignof(AAbilitySystemDebugHUD) == 0x000008, "Wrong alignment on AAbilitySystemDebugHUD");
|
|
static_assert(sizeof(AAbilitySystemDebugHUD) == 0x000310, "Wrong size on AAbilitySystemDebugHUD");
|
|
|
|
// Class GameplayAbilities.AbilitySystemGlobals
|
|
// 0x0238 (0x0260 - 0x0028)
|
|
class UAbilitySystemGlobals final : public UObject
|
|
{
|
|
public:
|
|
struct FSoftClassPath AbilitySystemGlobalsClassName; // 0x0028(0x0018)(ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_40[0x28]; // 0x0040(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayTag ActivateFailIsDeadTag; // 0x0068(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName ActivateFailIsDeadName; // 0x0070(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FGameplayTag ActivateFailCooldownTag; // 0x0078(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName ActivateFailCooldownName; // 0x0080(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FGameplayTag ActivateFailCostTag; // 0x0088(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName ActivateFailCostName; // 0x0090(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FGameplayTag ActivateFailTagsBlockedTag; // 0x0098(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName ActivateFailTagsBlockedName; // 0x00A0(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FGameplayTag ActivateFailTagsMissingTag; // 0x00A8(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName ActivateFailTagsMissingName; // 0x00B0(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FGameplayTag ActivateFailNetworkingTag; // 0x00B8(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName ActivateFailNetworkingName; // 0x00C0(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
int32 MinimalReplicationTagCountBits; // 0x00C8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_CC[0x4]; // 0x00CC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FNetSerializeScriptStructCache TargetDataStructCache; // 0x00D0(0x0010)(NativeAccessSpecifierPublic)
|
|
bool bAllowGameplayModEvaluationChannels; // 0x00E0(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
EGameplayModEvaluationChannel DefaultGameplayModEvaluationChannel; // 0x00E1(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_E2[0x2]; // 0x00E2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class FName GameplayModEvaluationChannelAliases[0xA]; // 0x00E4(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_134[0x4]; // 0x0134(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FSoftObjectPath GlobalCurveTableName; // 0x0138(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveTable* GlobalCurveTable; // 0x0150(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FSoftObjectPath GlobalAttributeMetaDataTableName; // 0x0158(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UDataTable* GlobalAttributeMetaDataTable; // 0x0170(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FSoftObjectPath GlobalAttributeSetDefaultsTableName; // 0x0178(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
TArray<struct FSoftObjectPath> GlobalAttributeSetDefaultsTableNames; // 0x0190(0x0010)(ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
|
|
TArray<class UCurveTable*> GlobalAttributeDefaultsTables; // 0x01A0(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
|
|
struct FSoftObjectPath GlobalGameplayCueManagerClass; // 0x01B0(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FSoftObjectPath GlobalGameplayCueManagerName; // 0x01C8(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
TArray<class FString> GameplayCueNotifyPaths; // 0x01E0(0x0010)(ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
|
|
struct FSoftObjectPath GameplayTagResponseTableName; // 0x01F0(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UGameplayTagReponseTable* GameplayTagResponseTable; // 0x0208(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool PredictTargetGameplayEffects; // 0x0210(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_211[0x7]; // 0x0211(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UGameplayCueManager* GlobalGameplayCueManager; // 0x0218(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_220[0x40]; // 0x0220(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void ListPlayerAbilities();
|
|
void ServerActivatePlayerAbility(const class FString& AbilityNameMatch);
|
|
void ServerCancelPlayerAbility(const class FString& AbilityNameMatch);
|
|
void ServerEndPlayerAbility(const class FString& AbilityNameMatch);
|
|
void ToggleIgnoreAbilitySystemCooldowns();
|
|
void ToggleIgnoreAbilitySystemCosts();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemGlobals">();
|
|
}
|
|
static class UAbilitySystemGlobals* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilitySystemGlobals>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilitySystemGlobals) == 0x000008, "Wrong alignment on UAbilitySystemGlobals");
|
|
static_assert(sizeof(UAbilitySystemGlobals) == 0x000260, "Wrong size on UAbilitySystemGlobals");
|
|
static_assert(offsetof(UAbilitySystemGlobals, AbilitySystemGlobalsClassName) == 0x000028, "Member 'UAbilitySystemGlobals::AbilitySystemGlobalsClassName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailIsDeadTag) == 0x000068, "Member 'UAbilitySystemGlobals::ActivateFailIsDeadTag' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailIsDeadName) == 0x000070, "Member 'UAbilitySystemGlobals::ActivateFailIsDeadName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCooldownTag) == 0x000078, "Member 'UAbilitySystemGlobals::ActivateFailCooldownTag' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCooldownName) == 0x000080, "Member 'UAbilitySystemGlobals::ActivateFailCooldownName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCostTag) == 0x000088, "Member 'UAbilitySystemGlobals::ActivateFailCostTag' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCostName) == 0x000090, "Member 'UAbilitySystemGlobals::ActivateFailCostName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsBlockedTag) == 0x000098, "Member 'UAbilitySystemGlobals::ActivateFailTagsBlockedTag' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsBlockedName) == 0x0000A0, "Member 'UAbilitySystemGlobals::ActivateFailTagsBlockedName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsMissingTag) == 0x0000A8, "Member 'UAbilitySystemGlobals::ActivateFailTagsMissingTag' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsMissingName) == 0x0000B0, "Member 'UAbilitySystemGlobals::ActivateFailTagsMissingName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailNetworkingTag) == 0x0000B8, "Member 'UAbilitySystemGlobals::ActivateFailNetworkingTag' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailNetworkingName) == 0x0000C0, "Member 'UAbilitySystemGlobals::ActivateFailNetworkingName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, MinimalReplicationTagCountBits) == 0x0000C8, "Member 'UAbilitySystemGlobals::MinimalReplicationTagCountBits' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, TargetDataStructCache) == 0x0000D0, "Member 'UAbilitySystemGlobals::TargetDataStructCache' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, bAllowGameplayModEvaluationChannels) == 0x0000E0, "Member 'UAbilitySystemGlobals::bAllowGameplayModEvaluationChannels' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, DefaultGameplayModEvaluationChannel) == 0x0000E1, "Member 'UAbilitySystemGlobals::DefaultGameplayModEvaluationChannel' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GameplayModEvaluationChannelAliases) == 0x0000E4, "Member 'UAbilitySystemGlobals::GameplayModEvaluationChannelAliases' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalCurveTableName) == 0x000138, "Member 'UAbilitySystemGlobals::GlobalCurveTableName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalCurveTable) == 0x000150, "Member 'UAbilitySystemGlobals::GlobalCurveTable' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeMetaDataTableName) == 0x000158, "Member 'UAbilitySystemGlobals::GlobalAttributeMetaDataTableName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeMetaDataTable) == 0x000170, "Member 'UAbilitySystemGlobals::GlobalAttributeMetaDataTable' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeSetDefaultsTableName) == 0x000178, "Member 'UAbilitySystemGlobals::GlobalAttributeSetDefaultsTableName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeSetDefaultsTableNames) == 0x000190, "Member 'UAbilitySystemGlobals::GlobalAttributeSetDefaultsTableNames' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeDefaultsTables) == 0x0001A0, "Member 'UAbilitySystemGlobals::GlobalAttributeDefaultsTables' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalGameplayCueManagerClass) == 0x0001B0, "Member 'UAbilitySystemGlobals::GlobalGameplayCueManagerClass' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalGameplayCueManagerName) == 0x0001C8, "Member 'UAbilitySystemGlobals::GlobalGameplayCueManagerName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GameplayCueNotifyPaths) == 0x0001E0, "Member 'UAbilitySystemGlobals::GameplayCueNotifyPaths' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GameplayTagResponseTableName) == 0x0001F0, "Member 'UAbilitySystemGlobals::GameplayTagResponseTableName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GameplayTagResponseTable) == 0x000208, "Member 'UAbilitySystemGlobals::GameplayTagResponseTable' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, PredictTargetGameplayEffects) == 0x000210, "Member 'UAbilitySystemGlobals::PredictTargetGameplayEffects' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemGlobals, GlobalGameplayCueManager) == 0x000218, "Member 'UAbilitySystemGlobals::GlobalGameplayCueManager' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilitySystemInterface
|
|
// 0x0000 (0x0000 - 0x0000)
|
|
class IAbilitySystemInterface final
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemInterface">();
|
|
}
|
|
static class IAbilitySystemInterface* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<IAbilitySystemInterface>();
|
|
}
|
|
|
|
class UObject* AsUObject()
|
|
{
|
|
return reinterpret_cast<UObject*>(this);
|
|
}
|
|
const class UObject* AsUObject() const
|
|
{
|
|
return reinterpret_cast<const UObject*>(this);
|
|
}
|
|
};
|
|
static_assert(alignof(IAbilitySystemInterface) == 0x000001, "Wrong alignment on IAbilitySystemInterface");
|
|
static_assert(sizeof(IAbilitySystemInterface) == 0x000001, "Wrong size on IAbilitySystemInterface");
|
|
|
|
// Class GameplayAbilities.AbilitySystemReplicationProxyInterface
|
|
// 0x0000 (0x0000 - 0x0000)
|
|
class IAbilitySystemReplicationProxyInterface final
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemReplicationProxyInterface">();
|
|
}
|
|
static class IAbilitySystemReplicationProxyInterface* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<IAbilitySystemReplicationProxyInterface>();
|
|
}
|
|
|
|
class UObject* AsUObject()
|
|
{
|
|
return reinterpret_cast<UObject*>(this);
|
|
}
|
|
const class UObject* AsUObject() const
|
|
{
|
|
return reinterpret_cast<const UObject*>(this);
|
|
}
|
|
};
|
|
static_assert(alignof(IAbilitySystemReplicationProxyInterface) == 0x000001, "Wrong alignment on IAbilitySystemReplicationProxyInterface");
|
|
static_assert(sizeof(IAbilitySystemReplicationProxyInterface) == 0x000001, "Wrong size on IAbilitySystemReplicationProxyInterface");
|
|
|
|
// Class GameplayAbilities.AttributeSet
|
|
// 0x0008 (0x0030 - 0x0028)
|
|
class UAttributeSet : public UObject
|
|
{
|
|
public:
|
|
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AttributeSet">();
|
|
}
|
|
static class UAttributeSet* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAttributeSet>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAttributeSet) == 0x000008, "Wrong alignment on UAttributeSet");
|
|
static_assert(sizeof(UAttributeSet) == 0x000030, "Wrong size on UAttributeSet");
|
|
|
|
// Class GameplayAbilities.AbilitySystemTestAttributeSet
|
|
// 0x0040 (0x0070 - 0x0030)
|
|
class UAbilitySystemTestAttributeSet final : public UAttributeSet
|
|
{
|
|
public:
|
|
float MaxHealth; // 0x0030(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float Health; // 0x0034(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float Mana; // 0x0038(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float MaxMana; // 0x003C(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float Damage; // 0x0040(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float SpellDamage; // 0x0044(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float PhysicalDamage; // 0x0048(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float CritChance; // 0x004C(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float CritMultiplier; // 0x0050(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float ArmorDamageReduction; // 0x0054(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float DodgeChance; // 0x0058(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float LifeSteal; // 0x005C(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float Strength; // 0x0060(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float StackingAttribute1; // 0x0064(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float StackingAttribute2; // 0x0068(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float NoStackAttribute; // 0x006C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemTestAttributeSet">();
|
|
}
|
|
static class UAbilitySystemTestAttributeSet* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilitySystemTestAttributeSet>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilitySystemTestAttributeSet) == 0x000008, "Wrong alignment on UAbilitySystemTestAttributeSet");
|
|
static_assert(sizeof(UAbilitySystemTestAttributeSet) == 0x000070, "Wrong size on UAbilitySystemTestAttributeSet");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, MaxHealth) == 0x000030, "Member 'UAbilitySystemTestAttributeSet::MaxHealth' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, Health) == 0x000034, "Member 'UAbilitySystemTestAttributeSet::Health' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, Mana) == 0x000038, "Member 'UAbilitySystemTestAttributeSet::Mana' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, MaxMana) == 0x00003C, "Member 'UAbilitySystemTestAttributeSet::MaxMana' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, Damage) == 0x000040, "Member 'UAbilitySystemTestAttributeSet::Damage' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, SpellDamage) == 0x000044, "Member 'UAbilitySystemTestAttributeSet::SpellDamage' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, PhysicalDamage) == 0x000048, "Member 'UAbilitySystemTestAttributeSet::PhysicalDamage' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, CritChance) == 0x00004C, "Member 'UAbilitySystemTestAttributeSet::CritChance' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, CritMultiplier) == 0x000050, "Member 'UAbilitySystemTestAttributeSet::CritMultiplier' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, ArmorDamageReduction) == 0x000054, "Member 'UAbilitySystemTestAttributeSet::ArmorDamageReduction' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, DodgeChance) == 0x000058, "Member 'UAbilitySystemTestAttributeSet::DodgeChance' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, LifeSteal) == 0x00005C, "Member 'UAbilitySystemTestAttributeSet::LifeSteal' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, Strength) == 0x000060, "Member 'UAbilitySystemTestAttributeSet::Strength' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, StackingAttribute1) == 0x000064, "Member 'UAbilitySystemTestAttributeSet::StackingAttribute1' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, StackingAttribute2) == 0x000068, "Member 'UAbilitySystemTestAttributeSet::StackingAttribute2' has a wrong offset!");
|
|
static_assert(offsetof(UAbilitySystemTestAttributeSet, NoStackAttribute) == 0x00006C, "Member 'UAbilitySystemTestAttributeSet::NoStackAttribute' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilitySystemTestPawn
|
|
// 0x0020 (0x02C8 - 0x02A8)
|
|
class AAbilitySystemTestPawn final : public ADefaultPawn
|
|
{
|
|
public:
|
|
uint8 Pad_2A8[0x18]; // 0x02A8(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* AbilitySystemComponent; // 0x02C0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilitySystemTestPawn">();
|
|
}
|
|
static class AAbilitySystemTestPawn* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AAbilitySystemTestPawn>();
|
|
}
|
|
};
|
|
static_assert(alignof(AAbilitySystemTestPawn) == 0x000008, "Wrong alignment on AAbilitySystemTestPawn");
|
|
static_assert(sizeof(AAbilitySystemTestPawn) == 0x0002C8, "Wrong size on AAbilitySystemTestPawn");
|
|
static_assert(offsetof(AAbilitySystemTestPawn, AbilitySystemComponent) == 0x0002C0, "Member 'AAbilitySystemTestPawn::AbilitySystemComponent' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask
|
|
// 0x0018 (0x0080 - 0x0068)
|
|
class UAbilityTask : public UGameplayTask
|
|
{
|
|
public:
|
|
class UGameplayAbility* Ability; // 0x0068(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class UAbilitySystemComponent* AbilitySystemComponent; // 0x0070(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_78[0x8]; // 0x0078(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask">();
|
|
}
|
|
static class UAbilityTask* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask) == 0x000008, "Wrong alignment on UAbilityTask");
|
|
static_assert(sizeof(UAbilityTask) == 0x000080, "Wrong size on UAbilityTask");
|
|
static_assert(offsetof(UAbilityTask, Ability) == 0x000068, "Member 'UAbilityTask::Ability' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask, AbilitySystemComponent) == 0x000070, "Member 'UAbilityTask::AbilitySystemComponent' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_ApplyRootMotion_Base
|
|
// 0x0038 (0x00B8 - 0x0080)
|
|
class UAbilityTask_ApplyRootMotion_Base : public UAbilityTask
|
|
{
|
|
public:
|
|
class FName ForceName; // 0x0080(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
ERootMotionFinishVelocityMode FinishVelocityMode; // 0x0088(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_89[0x3]; // 0x0089(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FVector FinishSetVelocity; // 0x008C(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float FinishClampVelocity; // 0x0098(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_9C[0x4]; // 0x009C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UCharacterMovementComponent* MovementComponent; // 0x00A0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_A8[0x10]; // 0x00A8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_ApplyRootMotion_Base">();
|
|
}
|
|
static class UAbilityTask_ApplyRootMotion_Base* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_ApplyRootMotion_Base>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_ApplyRootMotion_Base) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotion_Base");
|
|
static_assert(sizeof(UAbilityTask_ApplyRootMotion_Base) == 0x0000B8, "Wrong size on UAbilityTask_ApplyRootMotion_Base");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, ForceName) == 0x000080, "Member 'UAbilityTask_ApplyRootMotion_Base::ForceName' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, FinishVelocityMode) == 0x000088, "Member 'UAbilityTask_ApplyRootMotion_Base::FinishVelocityMode' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, FinishSetVelocity) == 0x00008C, "Member 'UAbilityTask_ApplyRootMotion_Base::FinishSetVelocity' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, FinishClampVelocity) == 0x000098, "Member 'UAbilityTask_ApplyRootMotion_Base::FinishClampVelocity' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, MovementComponent) == 0x0000A0, "Member 'UAbilityTask_ApplyRootMotion_Base::MovementComponent' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_ApplyRootMotionConstantForce
|
|
// 0x0038 (0x00F0 - 0x00B8)
|
|
class UAbilityTask_ApplyRootMotionConstantForce final : public UAbilityTask_ApplyRootMotion_Base
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnFinish; // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
struct FVector WorldDirection; // 0x00C8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Strength; // 0x00D4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Duration; // 0x00D8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bIsAdditive; // 0x00DC(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_DD[0x3]; // 0x00DD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UCurveFloat* StrengthOverTime; // 0x00E0(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bEnableGravity; // 0x00E8(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_E9[0x7]; // 0x00E9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_ApplyRootMotionConstantForce* ApplyRootMotionConstantForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& WorldDirection_0, float Strength_0, float Duration_0, bool bIsAdditive_0, class UCurveFloat* StrengthOverTime_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, bool bEnableGravity_0);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_ApplyRootMotionConstantForce">();
|
|
}
|
|
static class UAbilityTask_ApplyRootMotionConstantForce* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionConstantForce>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_ApplyRootMotionConstantForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionConstantForce");
|
|
static_assert(sizeof(UAbilityTask_ApplyRootMotionConstantForce) == 0x0000F0, "Wrong size on UAbilityTask_ApplyRootMotionConstantForce");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, OnFinish) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::OnFinish' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, WorldDirection) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::WorldDirection' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, Strength) == 0x0000D4, "Member 'UAbilityTask_ApplyRootMotionConstantForce::Strength' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, Duration) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::Duration' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, bIsAdditive) == 0x0000DC, "Member 'UAbilityTask_ApplyRootMotionConstantForce::bIsAdditive' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, StrengthOverTime) == 0x0000E0, "Member 'UAbilityTask_ApplyRootMotionConstantForce::StrengthOverTime' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, bEnableGravity) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::bEnableGravity' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_ApplyRootMotionJumpForce
|
|
// 0x0058 (0x0110 - 0x00B8)
|
|
class UAbilityTask_ApplyRootMotionJumpForce final : public UAbilityTask_ApplyRootMotion_Base
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnFinish; // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void()> OnLanded; // 0x00C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
struct FRotator Rotation; // 0x00D8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)
|
|
float Distance; // 0x00E4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Height; // 0x00E8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Duration; // 0x00EC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float MinimumLandedTriggerTime; // 0x00F0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bFinishOnLanded; // 0x00F4(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_F5[0x3]; // 0x00F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UCurveVector* PathOffsetCurve; // 0x00F8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveFloat* TimeMappingCurve; // 0x0100(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_108[0x8]; // 0x0108(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_ApplyRootMotionJumpForce* ApplyRootMotionJumpForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FRotator& Rotation_0, float Distance_0, float Height_0, float Duration_0, float MinimumLandedTriggerTime_0, bool bFinishOnLanded_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, class UCurveVector* PathOffsetCurve_0, class UCurveFloat* TimeMappingCurve_0);
|
|
|
|
void Finish();
|
|
void OnLandedCallback(const struct FHitResult& Hit);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_ApplyRootMotionJumpForce">();
|
|
}
|
|
static class UAbilityTask_ApplyRootMotionJumpForce* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionJumpForce>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_ApplyRootMotionJumpForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionJumpForce");
|
|
static_assert(sizeof(UAbilityTask_ApplyRootMotionJumpForce) == 0x000110, "Wrong size on UAbilityTask_ApplyRootMotionJumpForce");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, OnFinish) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::OnFinish' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, OnLanded) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::OnLanded' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Rotation) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Rotation' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Distance) == 0x0000E4, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Distance' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Height) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Height' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Duration) == 0x0000EC, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Duration' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, MinimumLandedTriggerTime) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionJumpForce::MinimumLandedTriggerTime' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, bFinishOnLanded) == 0x0000F4, "Member 'UAbilityTask_ApplyRootMotionJumpForce::bFinishOnLanded' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, PathOffsetCurve) == 0x0000F8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::PathOffsetCurve' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, TimeMappingCurve) == 0x000100, "Member 'UAbilityTask_ApplyRootMotionJumpForce::TimeMappingCurve' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_ApplyRootMotionMoveToActorForce
|
|
// 0x0078 (0x0130 - 0x00B8)
|
|
class UAbilityTask_ApplyRootMotionMoveToActorForce : public UAbilityTask_ApplyRootMotion_Base
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(bool DestinationReached, bool TimedOut, const struct FVector& FinalTargetLocation)> OnFinished; // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_C8[0x8]; // 0x00C8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FVector StartLocation; // 0x00D0(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FVector TargetLocation; // 0x00DC(0x000C)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class AActor* TargetActor; // 0x00E8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FVector TargetLocationOffset; // 0x00F0(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
ERootMotionMoveToActorTargetOffsetType OffsetAlignment; // 0x00FC(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_FD[0x3]; // 0x00FD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
|
|
float Duration; // 0x0100(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bDisableDestinationReachedInterrupt; // 0x0104(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bSetNewMovementMode; // 0x0105(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
EMovementMode NewMovementMode; // 0x0106(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bRestrictSpeedToExpected; // 0x0107(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveVector* PathOffsetCurve; // 0x0108(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveFloat* TimeMappingCurve; // 0x0110(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveFloat* TargetLerpSpeedHorizontalCurve; // 0x0118(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveFloat* TargetLerpSpeedVerticalCurve; // 0x0120(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_128[0x8]; // 0x0128(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_ApplyRootMotionMoveToActorForce* ApplyRootMotionMoveToActorForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, class AActor* TargetActor_0, const struct FVector& TargetLocationOffset_0, ERootMotionMoveToActorTargetOffsetType OffsetAlignment_0, float Duration_0, class UCurveFloat* TargetLerpSpeedHorizontal, class UCurveFloat* TargetLerpSpeedVertical, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveVector* PathOffsetCurve_0, class UCurveFloat* TimeMappingCurve_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, bool bDisableDestinationReachedInterrupt_0);
|
|
static class UAbilityTask_ApplyRootMotionMoveToActorForce* ApplyRootMotionMoveToTargetDataActorForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FGameplayAbilityTargetDataHandle& TargetDataHandle, int32 TargetDataIndex, int32 TargetActorIndex, const struct FVector& TargetLocationOffset_0, ERootMotionMoveToActorTargetOffsetType OffsetAlignment_0, float Duration_0, class UCurveFloat* TargetLerpSpeedHorizontal, class UCurveFloat* TargetLerpSpeedVertical, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveVector* PathOffsetCurve_0, class UCurveFloat* TimeMappingCurve_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, bool bDisableDestinationReachedInterrupt_0);
|
|
|
|
void OnRep_TargetLocation();
|
|
void OnTargetActorSwapped(class AActor* OriginalTarget, class AActor* NewTarget);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_ApplyRootMotionMoveToActorForce">();
|
|
}
|
|
static class UAbilityTask_ApplyRootMotionMoveToActorForce* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionMoveToActorForce>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_ApplyRootMotionMoveToActorForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionMoveToActorForce");
|
|
static_assert(sizeof(UAbilityTask_ApplyRootMotionMoveToActorForce) == 0x000130, "Wrong size on UAbilityTask_ApplyRootMotionMoveToActorForce");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, OnFinished) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::OnFinished' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, StartLocation) == 0x0000D0, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::StartLocation' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLocation) == 0x0000DC, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLocation' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetActor) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetActor' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLocationOffset) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLocationOffset' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, OffsetAlignment) == 0x0000FC, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::OffsetAlignment' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, Duration) == 0x000100, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::Duration' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, bDisableDestinationReachedInterrupt) == 0x000104, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::bDisableDestinationReachedInterrupt' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, bSetNewMovementMode) == 0x000105, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::bSetNewMovementMode' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, NewMovementMode) == 0x000106, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::NewMovementMode' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, bRestrictSpeedToExpected) == 0x000107, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::bRestrictSpeedToExpected' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, PathOffsetCurve) == 0x000108, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::PathOffsetCurve' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TimeMappingCurve) == 0x000110, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TimeMappingCurve' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLerpSpeedHorizontalCurve) == 0x000118, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLerpSpeedHorizontalCurve' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLerpSpeedVerticalCurve) == 0x000120, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLerpSpeedVerticalCurve' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_ApplyRootMotionMoveToForce
|
|
// 0x0050 (0x0108 - 0x00B8)
|
|
class UAbilityTask_ApplyRootMotionMoveToForce : public UAbilityTask_ApplyRootMotion_Base
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnTimedOut; // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void()> OnTimedOutAndDestinationReached; // 0x00C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
struct FVector StartLocation; // 0x00D8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FVector TargetLocation; // 0x00E4(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Duration; // 0x00F0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bSetNewMovementMode; // 0x00F4(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
EMovementMode NewMovementMode; // 0x00F5(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bRestrictSpeedToExpected; // 0x00F6(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_F7[0x1]; // 0x00F7(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UCurveVector* PathOffsetCurve; // 0x00F8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_100[0x8]; // 0x0100(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_ApplyRootMotionMoveToForce* ApplyRootMotionMoveToForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& TargetLocation_0, float Duration_0, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveVector* PathOffsetCurve_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_ApplyRootMotionMoveToForce">();
|
|
}
|
|
static class UAbilityTask_ApplyRootMotionMoveToForce* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionMoveToForce>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_ApplyRootMotionMoveToForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionMoveToForce");
|
|
static_assert(sizeof(UAbilityTask_ApplyRootMotionMoveToForce) == 0x000108, "Wrong size on UAbilityTask_ApplyRootMotionMoveToForce");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, OnTimedOut) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::OnTimedOut' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, OnTimedOutAndDestinationReached) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::OnTimedOutAndDestinationReached' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, StartLocation) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::StartLocation' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, TargetLocation) == 0x0000E4, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::TargetLocation' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, Duration) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::Duration' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, bSetNewMovementMode) == 0x0000F4, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::bSetNewMovementMode' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, NewMovementMode) == 0x0000F5, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::NewMovementMode' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, bRestrictSpeedToExpected) == 0x0000F6, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::bRestrictSpeedToExpected' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, PathOffsetCurve) == 0x0000F8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::PathOffsetCurve' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_ApplyRootMotionRadialForce
|
|
// 0x0058 (0x0110 - 0x00B8)
|
|
class UAbilityTask_ApplyRootMotionRadialForce final : public UAbilityTask_ApplyRootMotion_Base
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnFinish; // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
struct FVector Location; // 0x00C8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_D4[0x4]; // 0x00D4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class AActor* LocationActor; // 0x00D8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Strength; // 0x00E0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Duration; // 0x00E4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Radius; // 0x00E8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bIsPush; // 0x00EC(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bIsAdditive; // 0x00ED(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bNoZForce; // 0x00EE(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_EF[0x1]; // 0x00EF(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UCurveFloat* StrengthDistanceFalloff; // 0x00F0(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveFloat* StrengthOverTime; // 0x00F8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bUseFixedWorldDirection; // 0x0100(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_101[0x3]; // 0x0101(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FRotator FixedWorldDirection; // 0x0104(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)
|
|
|
|
public:
|
|
static class UAbilityTask_ApplyRootMotionRadialForce* ApplyRootMotionRadialForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& Location_0, class AActor* LocationActor_0, float Strength_0, float Duration_0, float Radius_0, bool bIsPush_0, bool bIsAdditive_0, bool bNoZForce_0, class UCurveFloat* StrengthDistanceFalloff_0, class UCurveFloat* StrengthOverTime_0, bool bUseFixedWorldDirection_0, const struct FRotator& FixedWorldDirection_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_ApplyRootMotionRadialForce">();
|
|
}
|
|
static class UAbilityTask_ApplyRootMotionRadialForce* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionRadialForce>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_ApplyRootMotionRadialForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionRadialForce");
|
|
static_assert(sizeof(UAbilityTask_ApplyRootMotionRadialForce) == 0x000110, "Wrong size on UAbilityTask_ApplyRootMotionRadialForce");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, OnFinish) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::OnFinish' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Location) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Location' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, LocationActor) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::LocationActor' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Strength) == 0x0000E0, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Strength' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Duration) == 0x0000E4, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Duration' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Radius) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Radius' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bIsPush) == 0x0000EC, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bIsPush' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bIsAdditive) == 0x0000ED, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bIsAdditive' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bNoZForce) == 0x0000EE, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bNoZForce' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, StrengthDistanceFalloff) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionRadialForce::StrengthDistanceFalloff' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, StrengthOverTime) == 0x0000F8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::StrengthOverTime' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bUseFixedWorldDirection) == 0x000100, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bUseFixedWorldDirection' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, FixedWorldDirection) == 0x000104, "Member 'UAbilityTask_ApplyRootMotionRadialForce::FixedWorldDirection' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_MoveToLocation
|
|
// 0x0048 (0x00C8 - 0x0080)
|
|
class UAbilityTask_MoveToLocation final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnTargetLocationReached; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x4]; // 0x0090(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FVector StartLocation; // 0x0094(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FVector TargetLocation; // 0x00A0(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float DurationOfMovement; // 0x00AC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_B0[0x8]; // 0x00B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UCurveFloat* LerpCurve; // 0x00B8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class UCurveVector* LerpCurveVector; // 0x00C0(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
|
|
public:
|
|
static class UAbilityTask_MoveToLocation* MoveToLocation(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& Location, float Duration, class UCurveFloat* OptionalInterpolationCurve, class UCurveVector* OptionalVectorInterpolationCurve);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_MoveToLocation">();
|
|
}
|
|
static class UAbilityTask_MoveToLocation* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_MoveToLocation>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_MoveToLocation) == 0x000008, "Wrong alignment on UAbilityTask_MoveToLocation");
|
|
static_assert(sizeof(UAbilityTask_MoveToLocation) == 0x0000C8, "Wrong size on UAbilityTask_MoveToLocation");
|
|
static_assert(offsetof(UAbilityTask_MoveToLocation, OnTargetLocationReached) == 0x000080, "Member 'UAbilityTask_MoveToLocation::OnTargetLocationReached' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_MoveToLocation, StartLocation) == 0x000094, "Member 'UAbilityTask_MoveToLocation::StartLocation' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_MoveToLocation, TargetLocation) == 0x0000A0, "Member 'UAbilityTask_MoveToLocation::TargetLocation' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_MoveToLocation, DurationOfMovement) == 0x0000AC, "Member 'UAbilityTask_MoveToLocation::DurationOfMovement' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_MoveToLocation, LerpCurve) == 0x0000B8, "Member 'UAbilityTask_MoveToLocation::LerpCurve' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_MoveToLocation, LerpCurveVector) == 0x0000C0, "Member 'UAbilityTask_MoveToLocation::LerpCurveVector' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_NetworkSyncPoint
|
|
// 0x0018 (0x0098 - 0x0080)
|
|
class UAbilityTask_NetworkSyncPoint final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnSync; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x8]; // 0x0090(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_NetworkSyncPoint* WaitNetSync(class UGameplayAbility* OwningAbility, EAbilityTaskNetSyncType SyncType);
|
|
|
|
void OnSignalCallback();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_NetworkSyncPoint">();
|
|
}
|
|
static class UAbilityTask_NetworkSyncPoint* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_NetworkSyncPoint>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_NetworkSyncPoint) == 0x000008, "Wrong alignment on UAbilityTask_NetworkSyncPoint");
|
|
static_assert(sizeof(UAbilityTask_NetworkSyncPoint) == 0x000098, "Wrong size on UAbilityTask_NetworkSyncPoint");
|
|
static_assert(offsetof(UAbilityTask_NetworkSyncPoint, OnSync) == 0x000080, "Member 'UAbilityTask_NetworkSyncPoint::OnSync' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_PlayMontageAndWait
|
|
// 0x0088 (0x0108 - 0x0080)
|
|
class UAbilityTask_PlayMontageAndWait : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnCompleted; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void()> OnBlendOut; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void()> OnInterrupted; // 0x00A0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void()> OnCancelled; // 0x00B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_C0[0x28]; // 0x00C0(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAnimMontage* MontageToPlay; // 0x00E8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float Rate; // 0x00F0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class FName StartSection; // 0x00F4(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float AnimRootMotionTranslationScale; // 0x00FC(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
float StartTimeSeconds; // 0x0100(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bStopWhenAbilityEnds; // 0x0104(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_105[0x3]; // 0x0105(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_PlayMontageAndWait* CreatePlayMontageAndWaitProxy(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, class UAnimMontage* MontageToPlay_0, float Rate_0, class FName StartSection_0, bool bStopWhenAbilityEnds_0, float AnimRootMotionTranslationScale_0, float StartTimeSeconds_0);
|
|
|
|
void OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted);
|
|
void OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted);
|
|
void OnMontageInterrupted();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_PlayMontageAndWait">();
|
|
}
|
|
static class UAbilityTask_PlayMontageAndWait* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_PlayMontageAndWait>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_PlayMontageAndWait) == 0x000008, "Wrong alignment on UAbilityTask_PlayMontageAndWait");
|
|
static_assert(sizeof(UAbilityTask_PlayMontageAndWait) == 0x000108, "Wrong size on UAbilityTask_PlayMontageAndWait");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnCompleted) == 0x000080, "Member 'UAbilityTask_PlayMontageAndWait::OnCompleted' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnBlendOut) == 0x000090, "Member 'UAbilityTask_PlayMontageAndWait::OnBlendOut' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnInterrupted) == 0x0000A0, "Member 'UAbilityTask_PlayMontageAndWait::OnInterrupted' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnCancelled) == 0x0000B0, "Member 'UAbilityTask_PlayMontageAndWait::OnCancelled' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, MontageToPlay) == 0x0000E8, "Member 'UAbilityTask_PlayMontageAndWait::MontageToPlay' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, Rate) == 0x0000F0, "Member 'UAbilityTask_PlayMontageAndWait::Rate' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, StartSection) == 0x0000F4, "Member 'UAbilityTask_PlayMontageAndWait::StartSection' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, AnimRootMotionTranslationScale) == 0x0000FC, "Member 'UAbilityTask_PlayMontageAndWait::AnimRootMotionTranslationScale' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, StartTimeSeconds) == 0x000100, "Member 'UAbilityTask_PlayMontageAndWait::StartTimeSeconds' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, bStopWhenAbilityEnds) == 0x000104, "Member 'UAbilityTask_PlayMontageAndWait::bStopWhenAbilityEnds' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_Repeat
|
|
// 0x0038 (0x00B8 - 0x0080)
|
|
class UAbilityTask_Repeat final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(int32 ActionNumber)> OnPerformAction; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void(int32 ActionNumber)> OnFinished; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_A0[0x18]; // 0x00A0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_Repeat* RepeatAction(class UGameplayAbility* OwningAbility, float TimeBetweenActions, int32 TotalActionCount);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_Repeat">();
|
|
}
|
|
static class UAbilityTask_Repeat* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_Repeat>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_Repeat) == 0x000008, "Wrong alignment on UAbilityTask_Repeat");
|
|
static_assert(sizeof(UAbilityTask_Repeat) == 0x0000B8, "Wrong size on UAbilityTask_Repeat");
|
|
static_assert(offsetof(UAbilityTask_Repeat, OnPerformAction) == 0x000080, "Member 'UAbilityTask_Repeat::OnPerformAction' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_Repeat, OnFinished) == 0x000090, "Member 'UAbilityTask_Repeat::OnFinished' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_SpawnActor
|
|
// 0x0048 (0x00C8 - 0x0080)
|
|
class UAbilityTask_SpawnActor final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(class AActor* SpawnedActor)> Success; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void(class AActor* SpawnedActor)> DidNotSpawn; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_A0[0x28]; // 0x00A0(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_SpawnActor* SpawnActor(class UGameplayAbility* OwningAbility, const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class AActor> Class_0);
|
|
|
|
bool BeginSpawningActor(class UGameplayAbility* OwningAbility, const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class AActor> Class_0, class AActor** SpawnedActor);
|
|
void FinishSpawningActor(class UGameplayAbility* OwningAbility, const struct FGameplayAbilityTargetDataHandle& TargetData, class AActor* SpawnedActor);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_SpawnActor">();
|
|
}
|
|
static class UAbilityTask_SpawnActor* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_SpawnActor>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_SpawnActor) == 0x000008, "Wrong alignment on UAbilityTask_SpawnActor");
|
|
static_assert(sizeof(UAbilityTask_SpawnActor) == 0x0000C8, "Wrong size on UAbilityTask_SpawnActor");
|
|
static_assert(offsetof(UAbilityTask_SpawnActor, Success) == 0x000080, "Member 'UAbilityTask_SpawnActor::Success' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_SpawnActor, DidNotSpawn) == 0x000090, "Member 'UAbilityTask_SpawnActor::DidNotSpawn' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_StartAbilityState
|
|
// 0x0038 (0x00B8 - 0x0080)
|
|
class UAbilityTask_StartAbilityState final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnStateEnded; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void()> OnStateInterrupted; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_A0[0x18]; // 0x00A0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_StartAbilityState* StartAbilityState(class UGameplayAbility* OwningAbility, class FName StateName, bool bEndCurrentState);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_StartAbilityState">();
|
|
}
|
|
static class UAbilityTask_StartAbilityState* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_StartAbilityState>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_StartAbilityState) == 0x000008, "Wrong alignment on UAbilityTask_StartAbilityState");
|
|
static_assert(sizeof(UAbilityTask_StartAbilityState) == 0x0000B8, "Wrong size on UAbilityTask_StartAbilityState");
|
|
static_assert(offsetof(UAbilityTask_StartAbilityState, OnStateEnded) == 0x000080, "Member 'UAbilityTask_StartAbilityState::OnStateEnded' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_StartAbilityState, OnStateInterrupted) == 0x000090, "Member 'UAbilityTask_StartAbilityState::OnStateInterrupted' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_VisualizeTargeting
|
|
// 0x0028 (0x00A8 - 0x0080)
|
|
class UAbilityTask_VisualizeTargeting final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> TimeElapsed; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x18]; // 0x0090(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_VisualizeTargeting* VisualizeTargeting(class UGameplayAbility* OwningAbility, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class FName TaskInstanceName, float Duration);
|
|
static class UAbilityTask_VisualizeTargeting* VisualizeTargetingUsingActor(class UGameplayAbility* OwningAbility, class AGameplayAbilityTargetActor* TargetActor, class FName TaskInstanceName, float Duration);
|
|
|
|
bool BeginSpawningActor(class UGameplayAbility* OwningAbility, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class AGameplayAbilityTargetActor** SpawnedActor);
|
|
void FinishSpawningActor(class UGameplayAbility* OwningAbility, class AGameplayAbilityTargetActor* SpawnedActor);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_VisualizeTargeting">();
|
|
}
|
|
static class UAbilityTask_VisualizeTargeting* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_VisualizeTargeting>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_VisualizeTargeting) == 0x000008, "Wrong alignment on UAbilityTask_VisualizeTargeting");
|
|
static_assert(sizeof(UAbilityTask_VisualizeTargeting) == 0x0000A8, "Wrong size on UAbilityTask_VisualizeTargeting");
|
|
static_assert(offsetof(UAbilityTask_VisualizeTargeting, TimeElapsed) == 0x000080, "Member 'UAbilityTask_VisualizeTargeting::TimeElapsed' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitAbilityActivate
|
|
// 0x00B8 (0x0138 - 0x0080)
|
|
class UAbilityTask_WaitAbilityActivate final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(class UGameplayAbility* ActivatedAbility)> OnActivate; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0xA8]; // 0x0090(0x00A8)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitAbilityActivate* WaitForAbilityActivate(class UGameplayAbility* OwningAbility, const struct FGameplayTag& WithTag, const struct FGameplayTag& WithoutTag, bool IncludeTriggeredAbilities, bool TriggerOnce);
|
|
static class UAbilityTask_WaitAbilityActivate* WaitForAbilityActivate_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTagQuery& Query, bool IncludeTriggeredAbilities, bool TriggerOnce);
|
|
static class UAbilityTask_WaitAbilityActivate* WaitForAbilityActivateWithTagRequirements(class UGameplayAbility* OwningAbility, const struct FGameplayTagRequirements& TagRequirements, bool IncludeTriggeredAbilities, bool TriggerOnce);
|
|
|
|
void OnAbilityActivate(class UGameplayAbility* ActivatedAbility);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitAbilityActivate">();
|
|
}
|
|
static class UAbilityTask_WaitAbilityActivate* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitAbilityActivate>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitAbilityActivate) == 0x000008, "Wrong alignment on UAbilityTask_WaitAbilityActivate");
|
|
static_assert(sizeof(UAbilityTask_WaitAbilityActivate) == 0x000138, "Wrong size on UAbilityTask_WaitAbilityActivate");
|
|
static_assert(offsetof(UAbilityTask_WaitAbilityActivate, OnActivate) == 0x000080, "Member 'UAbilityTask_WaitAbilityActivate::OnActivate' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitAbilityCommit
|
|
// 0x0078 (0x00F8 - 0x0080)
|
|
class UAbilityTask_WaitAbilityCommit final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(class UGameplayAbility* ActivatedAbility)> OnCommit; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x68]; // 0x0090(0x0068)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitAbilityCommit* WaitForAbilityCommit(class UGameplayAbility* OwningAbility, const struct FGameplayTag& WithTag, const struct FGameplayTag& WithoutTage, bool TriggerOnce);
|
|
static class UAbilityTask_WaitAbilityCommit* WaitForAbilityCommit_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTagQuery& Query, bool TriggerOnce);
|
|
|
|
void OnAbilityCommit(class UGameplayAbility* ActivatedAbility);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitAbilityCommit">();
|
|
}
|
|
static class UAbilityTask_WaitAbilityCommit* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitAbilityCommit>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitAbilityCommit) == 0x000008, "Wrong alignment on UAbilityTask_WaitAbilityCommit");
|
|
static_assert(sizeof(UAbilityTask_WaitAbilityCommit) == 0x0000F8, "Wrong size on UAbilityTask_WaitAbilityCommit");
|
|
static_assert(offsetof(UAbilityTask_WaitAbilityCommit, OnCommit) == 0x000080, "Member 'UAbilityTask_WaitAbilityCommit::OnCommit' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitAttributeChange
|
|
// 0x0078 (0x00F8 - 0x0080)
|
|
class UAbilityTask_WaitAttributeChange final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnChange; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x60]; // 0x0090(0x0060)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* ExternalOwner; // 0x00F0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
|
|
public:
|
|
static class UAbilityTask_WaitAttributeChange* WaitForAttributeChange(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& Attribute, const struct FGameplayTag& WithSrcTag, const struct FGameplayTag& WithoutSrcTag, bool TriggerOnce, class AActor* OptionalExternalOwner);
|
|
static class UAbilityTask_WaitAttributeChange* WaitForAttributeChangeWithComparison(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& InAttribute, const struct FGameplayTag& InWithTag, const struct FGameplayTag& InWithoutTag, EWaitAttributeChangeComparison InComparisonType, float InComparisonValue, bool TriggerOnce, class AActor* OptionalExternalOwner);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitAttributeChange">();
|
|
}
|
|
static class UAbilityTask_WaitAttributeChange* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitAttributeChange>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitAttributeChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitAttributeChange");
|
|
static_assert(sizeof(UAbilityTask_WaitAttributeChange) == 0x0000F8, "Wrong size on UAbilityTask_WaitAttributeChange");
|
|
static_assert(offsetof(UAbilityTask_WaitAttributeChange, OnChange) == 0x000080, "Member 'UAbilityTask_WaitAttributeChange::OnChange' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitAttributeChange, ExternalOwner) == 0x0000F0, "Member 'UAbilityTask_WaitAttributeChange::ExternalOwner' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitAttributeChangeRatioThreshold
|
|
// 0x00C0 (0x0140 - 0x0080)
|
|
class UAbilityTask_WaitAttributeChangeRatioThreshold final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(bool bMatchesComparison, float CurrentRatio)> OnChange; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0xA8]; // 0x0090(0x00A8)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* ExternalOwner; // 0x0138(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
|
|
public:
|
|
static class UAbilityTask_WaitAttributeChangeRatioThreshold* WaitForAttributeChangeRatioThreshold(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& AttributeNumerator, const struct FGameplayAttribute& AttributeDenominator, EWaitAttributeChangeComparison ComparisonType, float ComparisonValue, bool bTriggerOnce, class AActor* OptionalExternalOwner);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitAttributeChangeRatioThreshold">();
|
|
}
|
|
static class UAbilityTask_WaitAttributeChangeRatioThreshold* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitAttributeChangeRatioThreshold>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitAttributeChangeRatioThreshold) == 0x000008, "Wrong alignment on UAbilityTask_WaitAttributeChangeRatioThreshold");
|
|
static_assert(sizeof(UAbilityTask_WaitAttributeChangeRatioThreshold) == 0x000140, "Wrong size on UAbilityTask_WaitAttributeChangeRatioThreshold");
|
|
static_assert(offsetof(UAbilityTask_WaitAttributeChangeRatioThreshold, OnChange) == 0x000080, "Member 'UAbilityTask_WaitAttributeChangeRatioThreshold::OnChange' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitAttributeChangeRatioThreshold, ExternalOwner) == 0x000138, "Member 'UAbilityTask_WaitAttributeChangeRatioThreshold::ExternalOwner' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitAttributeChangeThreshold
|
|
// 0x0070 (0x00F0 - 0x0080)
|
|
class UAbilityTask_WaitAttributeChangeThreshold final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(bool bMatchesComparison, float CurrentValue)> OnChange; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x58]; // 0x0090(0x0058)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* ExternalOwner; // 0x00E8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
|
|
public:
|
|
static class UAbilityTask_WaitAttributeChangeThreshold* WaitForAttributeChangeThreshold(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& Attribute, EWaitAttributeChangeComparison ComparisonType, float ComparisonValue, bool bTriggerOnce, class AActor* OptionalExternalOwner);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitAttributeChangeThreshold">();
|
|
}
|
|
static class UAbilityTask_WaitAttributeChangeThreshold* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitAttributeChangeThreshold>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitAttributeChangeThreshold) == 0x000008, "Wrong alignment on UAbilityTask_WaitAttributeChangeThreshold");
|
|
static_assert(sizeof(UAbilityTask_WaitAttributeChangeThreshold) == 0x0000F0, "Wrong size on UAbilityTask_WaitAttributeChangeThreshold");
|
|
static_assert(offsetof(UAbilityTask_WaitAttributeChangeThreshold, OnChange) == 0x000080, "Member 'UAbilityTask_WaitAttributeChangeThreshold::OnChange' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitAttributeChangeThreshold, ExternalOwner) == 0x0000E8, "Member 'UAbilityTask_WaitAttributeChangeThreshold::ExternalOwner' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitCancel
|
|
// 0x0018 (0x0098 - 0x0080)
|
|
class UAbilityTask_WaitCancel final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnCancel; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x8]; // 0x0090(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitCancel* WaitCancel(class UGameplayAbility* OwningAbility);
|
|
|
|
void OnCancelCallback();
|
|
void OnLocalCancelCallback();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitCancel">();
|
|
}
|
|
static class UAbilityTask_WaitCancel* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitCancel>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitCancel) == 0x000008, "Wrong alignment on UAbilityTask_WaitCancel");
|
|
static_assert(sizeof(UAbilityTask_WaitCancel) == 0x000098, "Wrong size on UAbilityTask_WaitCancel");
|
|
static_assert(offsetof(UAbilityTask_WaitCancel, OnCancel) == 0x000080, "Member 'UAbilityTask_WaitCancel::OnCancel' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitConfirm
|
|
// 0x0020 (0x00A0 - 0x0080)
|
|
class UAbilityTask_WaitConfirm final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnConfirm; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x10]; // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitConfirm* WaitConfirm(class UGameplayAbility* OwningAbility);
|
|
|
|
void OnConfirmCallback(class UGameplayAbility* InAbility);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitConfirm">();
|
|
}
|
|
static class UAbilityTask_WaitConfirm* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitConfirm>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitConfirm) == 0x000008, "Wrong alignment on UAbilityTask_WaitConfirm");
|
|
static_assert(sizeof(UAbilityTask_WaitConfirm) == 0x0000A0, "Wrong size on UAbilityTask_WaitConfirm");
|
|
static_assert(offsetof(UAbilityTask_WaitConfirm, OnConfirm) == 0x000080, "Member 'UAbilityTask_WaitConfirm::OnConfirm' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitConfirmCancel
|
|
// 0x0028 (0x00A8 - 0x0080)
|
|
class UAbilityTask_WaitConfirmCancel final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnConfirm; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void()> OnCancel; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_A0[0x8]; // 0x00A0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitConfirmCancel* WaitConfirmCancel(class UGameplayAbility* OwningAbility);
|
|
|
|
void OnCancelCallback();
|
|
void OnConfirmCallback();
|
|
void OnLocalCancelCallback();
|
|
void OnLocalConfirmCallback();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitConfirmCancel">();
|
|
}
|
|
static class UAbilityTask_WaitConfirmCancel* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitConfirmCancel>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitConfirmCancel) == 0x000008, "Wrong alignment on UAbilityTask_WaitConfirmCancel");
|
|
static_assert(sizeof(UAbilityTask_WaitConfirmCancel) == 0x0000A8, "Wrong size on UAbilityTask_WaitConfirmCancel");
|
|
static_assert(offsetof(UAbilityTask_WaitConfirmCancel, OnConfirm) == 0x000080, "Member 'UAbilityTask_WaitConfirmCancel::OnConfirm' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitConfirmCancel, OnCancel) == 0x000090, "Member 'UAbilityTask_WaitConfirmCancel::OnCancel' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitDelay
|
|
// 0x0018 (0x0098 - 0x0080)
|
|
class UAbilityTask_WaitDelay final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnFinish; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x8]; // 0x0090(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitDelay* WaitDelay(class UGameplayAbility* OwningAbility, float Time);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitDelay">();
|
|
}
|
|
static class UAbilityTask_WaitDelay* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitDelay>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitDelay) == 0x000008, "Wrong alignment on UAbilityTask_WaitDelay");
|
|
static_assert(sizeof(UAbilityTask_WaitDelay) == 0x000098, "Wrong size on UAbilityTask_WaitDelay");
|
|
static_assert(offsetof(UAbilityTask_WaitDelay, OnFinish) == 0x000080, "Member 'UAbilityTask_WaitDelay::OnFinish' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayEffectApplied
|
|
// 0x0138 (0x01B8 - 0x0080)
|
|
class UAbilityTask_WaitGameplayEffectApplied : public UAbilityTask
|
|
{
|
|
public:
|
|
uint8 Pad_80[0x128]; // 0x0080(0x0128)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* ExternalOwner; // 0x01A8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_1B0[0x8]; // 0x01B0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void OnApplyGameplayEffectCallback(class UAbilitySystemComponent* Target, const struct FGameplayEffectSpec& SpecApplied, const struct FActiveGameplayEffectHandle& ActiveHandle);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayEffectApplied">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayEffectApplied* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectApplied>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayEffectApplied) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectApplied");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayEffectApplied) == 0x0001B8, "Wrong size on UAbilityTask_WaitGameplayEffectApplied");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectApplied, ExternalOwner) == 0x0001A8, "Member 'UAbilityTask_WaitGameplayEffectApplied::ExternalOwner' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayEffectApplied_Self
|
|
// 0x0020 (0x01D8 - 0x01B8)
|
|
class UAbilityTask_WaitGameplayEffectApplied_Self final : public UAbilityTask_WaitGameplayEffectApplied
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(class AActor* Source, const struct FGameplayEffectSpecHandle& SpecHandle, const struct FActiveGameplayEffectHandle& ActiveHandle)> OnApplied; // 0x01B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_1C8[0x10]; // 0x01C8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayEffectApplied_Self* WaitGameplayEffectAppliedToSelf(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffect);
|
|
static class UAbilityTask_WaitGameplayEffectApplied_Self* WaitGameplayEffectAppliedToSelf_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagQuery& SourceTagQuery, const struct FGameplayTagQuery& TargetTagQuery, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffect);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayEffectApplied_Self">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayEffectApplied_Self* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectApplied_Self>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayEffectApplied_Self) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectApplied_Self");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayEffectApplied_Self) == 0x0001D8, "Wrong size on UAbilityTask_WaitGameplayEffectApplied_Self");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectApplied_Self, OnApplied) == 0x0001B8, "Member 'UAbilityTask_WaitGameplayEffectApplied_Self::OnApplied' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayEffectApplied_Target
|
|
// 0x0020 (0x01D8 - 0x01B8)
|
|
class UAbilityTask_WaitGameplayEffectApplied_Target final : public UAbilityTask_WaitGameplayEffectApplied
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(class AActor* Target, const struct FGameplayEffectSpecHandle& SpecHandle, const struct FActiveGameplayEffectHandle& ActiveHandle)> OnApplied; // 0x01B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_1C8[0x10]; // 0x01C8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayEffectApplied_Target* WaitGameplayEffectAppliedToTarget(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& TargetFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffects);
|
|
static class UAbilityTask_WaitGameplayEffectApplied_Target* WaitGameplayEffectAppliedToTarget_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagQuery& SourceTagQuery, const struct FGameplayTagQuery& TargetTagQuery, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffect);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayEffectApplied_Target">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayEffectApplied_Target* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectApplied_Target>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayEffectApplied_Target) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectApplied_Target");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayEffectApplied_Target) == 0x0001D8, "Wrong size on UAbilityTask_WaitGameplayEffectApplied_Target");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectApplied_Target, OnApplied) == 0x0001B8, "Member 'UAbilityTask_WaitGameplayEffectApplied_Target::OnApplied' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayEffectBlockedImmunity
|
|
// 0x00A8 (0x0128 - 0x0080)
|
|
class UAbilityTask_WaitGameplayEffectBlockedImmunity final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(const struct FGameplayEffectSpecHandle& BlockedSpec, const struct FActiveGameplayEffectHandle& ImmunityGameplayEffectHandle)> bLocked; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x88]; // 0x0090(0x0088)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* ExternalOwner; // 0x0118(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_120[0x8]; // 0x0120(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayEffectBlockedImmunity* WaitGameplayEffectBlockedByImmunity(class UGameplayAbility* OwningAbility, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, class AActor* OptionalExternalTarget, bool OnlyTriggerOnce);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayEffectBlockedImmunity">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayEffectBlockedImmunity* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectBlockedImmunity>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayEffectBlockedImmunity) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectBlockedImmunity");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayEffectBlockedImmunity) == 0x000128, "Wrong size on UAbilityTask_WaitGameplayEffectBlockedImmunity");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectBlockedImmunity, bLocked) == 0x000080, "Member 'UAbilityTask_WaitGameplayEffectBlockedImmunity::bLocked' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectBlockedImmunity, ExternalOwner) == 0x000118, "Member 'UAbilityTask_WaitGameplayEffectBlockedImmunity::ExternalOwner' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayEffectRemoved
|
|
// 0x0040 (0x00C0 - 0x0080)
|
|
class UAbilityTask_WaitGameplayEffectRemoved final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(const struct FGameplayEffectRemovalInfo& GameplayEffectRemovalInfo)> OnRemoved; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void(const struct FGameplayEffectRemovalInfo& GameplayEffectRemovalInfo)> InvalidHandle; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_A0[0x20]; // 0x00A0(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayEffectRemoved* WaitForGameplayEffectRemoved(class UGameplayAbility* OwningAbility, const struct FActiveGameplayEffectHandle& Handle);
|
|
|
|
void OnGameplayEffectRemoved(const struct FGameplayEffectRemovalInfo& InGameplayEffectRemovalInfo);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayEffectRemoved">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayEffectRemoved* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectRemoved>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayEffectRemoved) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectRemoved");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayEffectRemoved) == 0x0000C0, "Wrong size on UAbilityTask_WaitGameplayEffectRemoved");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectRemoved, OnRemoved) == 0x000080, "Member 'UAbilityTask_WaitGameplayEffectRemoved::OnRemoved' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectRemoved, InvalidHandle) == 0x000090, "Member 'UAbilityTask_WaitGameplayEffectRemoved::InvalidHandle' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayEffectStackChange
|
|
// 0x0038 (0x00B8 - 0x0080)
|
|
class UAbilityTask_WaitGameplayEffectStackChange final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(const struct FActiveGameplayEffectHandle& Handle, int32 NewCount, int32 OldCount)> OnChange; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void(const struct FActiveGameplayEffectHandle& Handle, int32 NewCount, int32 OldCount)> InvalidHandle; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_A0[0x18]; // 0x00A0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayEffectStackChange* WaitForGameplayEffectStackChange(class UGameplayAbility* OwningAbility, const struct FActiveGameplayEffectHandle& Handle);
|
|
|
|
void OnGameplayEffectStackChange(const struct FActiveGameplayEffectHandle& Handle, int32 NewCount, int32 OldCount);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayEffectStackChange">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayEffectStackChange* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectStackChange>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayEffectStackChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectStackChange");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayEffectStackChange) == 0x0000B8, "Wrong size on UAbilityTask_WaitGameplayEffectStackChange");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectStackChange, OnChange) == 0x000080, "Member 'UAbilityTask_WaitGameplayEffectStackChange::OnChange' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEffectStackChange, InvalidHandle) == 0x000090, "Member 'UAbilityTask_WaitGameplayEffectStackChange::InvalidHandle' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayEvent
|
|
// 0x0030 (0x00B0 - 0x0080)
|
|
class UAbilityTask_WaitGameplayEvent final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(const struct FGameplayEventData& Payload)> EventReceived; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x8]; // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* OptionalExternalTarget; // 0x0098(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_A0[0x10]; // 0x00A0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayEvent* WaitGameplayEvent(class UGameplayAbility* OwningAbility, const struct FGameplayTag& EventTag, class AActor* OptionalExternalTarget_0, bool OnlyTriggerOnce, bool OnlyMatchExact);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayEvent">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayEvent* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayEvent>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayEvent) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEvent");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayEvent) == 0x0000B0, "Wrong size on UAbilityTask_WaitGameplayEvent");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEvent, EventReceived) == 0x000080, "Member 'UAbilityTask_WaitGameplayEvent::EventReceived' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayEvent, OptionalExternalTarget) == 0x000098, "Member 'UAbilityTask_WaitGameplayEvent::OptionalExternalTarget' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayTag
|
|
// 0x0028 (0x00A8 - 0x0080)
|
|
class UAbilityTask_WaitGameplayTag : public UAbilityTask
|
|
{
|
|
public:
|
|
uint8 Pad_80[0x10]; // 0x0080(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAbilitySystemComponent* OptionalExternalTarget; // 0x0090(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_98[0x10]; // 0x0098(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void GameplayTagCallback(const struct FGameplayTag& Tag, int32 NewCount);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayTag">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayTag* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayTag>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayTag) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayTag");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayTag) == 0x0000A8, "Wrong size on UAbilityTask_WaitGameplayTag");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayTag, OptionalExternalTarget) == 0x000090, "Member 'UAbilityTask_WaitGameplayTag::OptionalExternalTarget' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayTagAdded
|
|
// 0x0010 (0x00B8 - 0x00A8)
|
|
class UAbilityTask_WaitGameplayTagAdded final : public UAbilityTask_WaitGameplayTag
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> Added; // 0x00A8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayTagAdded* WaitGameplayTagAdd(class UGameplayAbility* OwningAbility, const struct FGameplayTag& Tag, class AActor* InOptionalExternalTarget, bool OnlyTriggerOnce);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayTagAdded">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayTagAdded* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayTagAdded>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayTagAdded) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayTagAdded");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayTagAdded) == 0x0000B8, "Wrong size on UAbilityTask_WaitGameplayTagAdded");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayTagAdded, Added) == 0x0000A8, "Member 'UAbilityTask_WaitGameplayTagAdded::Added' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitGameplayTagRemoved
|
|
// 0x0010 (0x00B8 - 0x00A8)
|
|
class UAbilityTask_WaitGameplayTagRemoved final : public UAbilityTask_WaitGameplayTag
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> Removed; // 0x00A8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UAbilityTask_WaitGameplayTagRemoved* WaitGameplayTagRemove(class UGameplayAbility* OwningAbility, const struct FGameplayTag& Tag, class AActor* InOptionalExternalTarget, bool OnlyTriggerOnce);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitGameplayTagRemoved">();
|
|
}
|
|
static class UAbilityTask_WaitGameplayTagRemoved* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitGameplayTagRemoved>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitGameplayTagRemoved) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayTagRemoved");
|
|
static_assert(sizeof(UAbilityTask_WaitGameplayTagRemoved) == 0x0000B8, "Wrong size on UAbilityTask_WaitGameplayTagRemoved");
|
|
static_assert(offsetof(UAbilityTask_WaitGameplayTagRemoved, Removed) == 0x0000A8, "Member 'UAbilityTask_WaitGameplayTagRemoved::Removed' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitInputPress
|
|
// 0x0020 (0x00A0 - 0x0080)
|
|
class UAbilityTask_WaitInputPress final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(float TimeWaited)> OnPress; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x10]; // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitInputPress* WaitInputPress(class UGameplayAbility* OwningAbility, bool bTestAlreadyPressed);
|
|
|
|
void OnPressCallback();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitInputPress">();
|
|
}
|
|
static class UAbilityTask_WaitInputPress* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitInputPress>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitInputPress) == 0x000008, "Wrong alignment on UAbilityTask_WaitInputPress");
|
|
static_assert(sizeof(UAbilityTask_WaitInputPress) == 0x0000A0, "Wrong size on UAbilityTask_WaitInputPress");
|
|
static_assert(offsetof(UAbilityTask_WaitInputPress, OnPress) == 0x000080, "Member 'UAbilityTask_WaitInputPress::OnPress' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitInputRelease
|
|
// 0x0020 (0x00A0 - 0x0080)
|
|
class UAbilityTask_WaitInputRelease final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(float TimeHeld)> OnRelease; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x10]; // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitInputRelease* WaitInputRelease(class UGameplayAbility* OwningAbility, bool bTestAlreadyReleased);
|
|
|
|
void OnReleaseCallback();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitInputRelease">();
|
|
}
|
|
static class UAbilityTask_WaitInputRelease* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitInputRelease>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitInputRelease) == 0x000008, "Wrong alignment on UAbilityTask_WaitInputRelease");
|
|
static_assert(sizeof(UAbilityTask_WaitInputRelease) == 0x0000A0, "Wrong size on UAbilityTask_WaitInputRelease");
|
|
static_assert(offsetof(UAbilityTask_WaitInputRelease, OnRelease) == 0x000080, "Member 'UAbilityTask_WaitInputRelease::OnRelease' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitMovementModeChange
|
|
// 0x0020 (0x00A0 - 0x0080)
|
|
class UAbilityTask_WaitMovementModeChange final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(EMovementMode NewMovementMode)> OnChange; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_90[0x10]; // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitMovementModeChange* CreateWaitMovementModeChange(class UGameplayAbility* OwningAbility, EMovementMode NewMode);
|
|
|
|
void OnMovementModeChange(class ACharacter* Character, EMovementMode PrevMovementMode, uint8 PreviousCustomMode);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitMovementModeChange">();
|
|
}
|
|
static class UAbilityTask_WaitMovementModeChange* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitMovementModeChange>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitMovementModeChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitMovementModeChange");
|
|
static_assert(sizeof(UAbilityTask_WaitMovementModeChange) == 0x0000A0, "Wrong size on UAbilityTask_WaitMovementModeChange");
|
|
static_assert(offsetof(UAbilityTask_WaitMovementModeChange, OnChange) == 0x000080, "Member 'UAbilityTask_WaitMovementModeChange::OnChange' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitOverlap
|
|
// 0x0010 (0x0090 - 0x0080)
|
|
class UAbilityTask_WaitOverlap final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(const struct FGameplayAbilityTargetDataHandle& TargetData)> OnOverlap; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UAbilityTask_WaitOverlap* WaitForOverlap(class UGameplayAbility* OwningAbility);
|
|
|
|
void OnHitCallback(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitOverlap">();
|
|
}
|
|
static class UAbilityTask_WaitOverlap* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitOverlap>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitOverlap) == 0x000008, "Wrong alignment on UAbilityTask_WaitOverlap");
|
|
static_assert(sizeof(UAbilityTask_WaitOverlap) == 0x000090, "Wrong size on UAbilityTask_WaitOverlap");
|
|
static_assert(offsetof(UAbilityTask_WaitOverlap, OnOverlap) == 0x000080, "Member 'UAbilityTask_WaitOverlap::OnOverlap' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitTargetData
|
|
// 0x0040 (0x00C0 - 0x0080)
|
|
class UAbilityTask_WaitTargetData final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void(const struct FGameplayAbilityTargetDataHandle& Data)> ValidData; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TMulticastInlineDelegate<void(const struct FGameplayAbilityTargetDataHandle& Data)> Cancelled; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
TSubclassOf<class AGameplayAbilityTargetActor> TargetClass; // 0x00A0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class AGameplayAbilityTargetActor* TargetActor; // 0x00A8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_B0[0x10]; // 0x00B0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitTargetData* WaitTargetData(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, EGameplayTargetingConfirmation ConfirmationType, TSubclassOf<class AGameplayAbilityTargetActor> Class_0);
|
|
static class UAbilityTask_WaitTargetData* WaitTargetDataUsingActor(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, EGameplayTargetingConfirmation ConfirmationType, class AGameplayAbilityTargetActor* TargetActor_0);
|
|
|
|
bool BeginSpawningActor(class UGameplayAbility* OwningAbility, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class AGameplayAbilityTargetActor** SpawnedActor);
|
|
void FinishSpawningActor(class UGameplayAbility* OwningAbility, class AGameplayAbilityTargetActor* SpawnedActor);
|
|
void OnTargetDataCancelledCallback(const struct FGameplayAbilityTargetDataHandle& Data);
|
|
void OnTargetDataReadyCallback(const struct FGameplayAbilityTargetDataHandle& Data);
|
|
void OnTargetDataReplicatedCallback(const struct FGameplayAbilityTargetDataHandle& Data, const struct FGameplayTag& ActivationTag);
|
|
void OnTargetDataReplicatedCancelledCallback();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitTargetData">();
|
|
}
|
|
static class UAbilityTask_WaitTargetData* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitTargetData>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitTargetData) == 0x000008, "Wrong alignment on UAbilityTask_WaitTargetData");
|
|
static_assert(sizeof(UAbilityTask_WaitTargetData) == 0x0000C0, "Wrong size on UAbilityTask_WaitTargetData");
|
|
static_assert(offsetof(UAbilityTask_WaitTargetData, ValidData) == 0x000080, "Member 'UAbilityTask_WaitTargetData::ValidData' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitTargetData, Cancelled) == 0x000090, "Member 'UAbilityTask_WaitTargetData::Cancelled' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitTargetData, TargetClass) == 0x0000A0, "Member 'UAbilityTask_WaitTargetData::TargetClass' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitTargetData, TargetActor) == 0x0000A8, "Member 'UAbilityTask_WaitTargetData::TargetActor' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.AbilityTask_WaitVelocityChange
|
|
// 0x0028 (0x00A8 - 0x0080)
|
|
class UAbilityTask_WaitVelocityChange final : public UAbilityTask
|
|
{
|
|
public:
|
|
TMulticastInlineDelegate<void()> OnVelocityChage; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
class UMovementComponent* CachedMovementComponent; // 0x0090(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_98[0x10]; // 0x0098(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UAbilityTask_WaitVelocityChange* CreateWaitVelocityChange(class UGameplayAbility* OwningAbility, const struct FVector& Direction, float MinimumMagnitude);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"AbilityTask_WaitVelocityChange">();
|
|
}
|
|
static class UAbilityTask_WaitVelocityChange* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UAbilityTask_WaitVelocityChange>();
|
|
}
|
|
};
|
|
static_assert(alignof(UAbilityTask_WaitVelocityChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitVelocityChange");
|
|
static_assert(sizeof(UAbilityTask_WaitVelocityChange) == 0x0000A8, "Wrong size on UAbilityTask_WaitVelocityChange");
|
|
static_assert(offsetof(UAbilityTask_WaitVelocityChange, OnVelocityChage) == 0x000080, "Member 'UAbilityTask_WaitVelocityChange::OnVelocityChage' has a wrong offset!");
|
|
static_assert(offsetof(UAbilityTask_WaitVelocityChange, CachedMovementComponent) == 0x000090, "Member 'UAbilityTask_WaitVelocityChange::CachedMovementComponent' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbility
|
|
// 0x0388 (0x03B0 - 0x0028)
|
|
class UGameplayAbility : public UObject
|
|
{
|
|
public:
|
|
uint8 Pad_28[0x80]; // 0x0028(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayTagContainer AbilityTags; // 0x00A8(0x0020)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
bool bReplicateInputDirectly; // 0x00C8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool RemoteInstanceEnded; // 0x00C9(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_CA[0x4]; // 0x00CA(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
EGameplayAbilityReplicationPolicy ReplicationPolicy; // 0x00CE(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
EGameplayAbilityInstancingPolicy InstancingPolicy; // 0x00CF(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bServerRespectsRemoteAbilityCancellation; // 0x00D0(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bRetriggerInstancedAbility; // 0x00D1(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_D2[0x6]; // 0x00D2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayAbilityActivationInfo CurrentActivationInfo; // 0x00D8(0x0018)(BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayEventData CurrentEventData; // 0x00F0(0x00B0)(BlueprintVisible, BlueprintReadOnly, Protected, NativeAccessSpecifierProtected)
|
|
EGameplayAbilityNetExecutionPolicy NetExecutionPolicy; // 0x01A0(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
EGameplayAbilityNetSecurityPolicy NetSecurityPolicy; // 0x01A1(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_1A2[0x6]; // 0x01A2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TSubclassOf<class UGameplayEffect> CostGameplayEffectClass; // 0x01A8(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
TArray<struct FAbilityTriggerData> AbilityTriggers; // 0x01B0(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
TSubclassOf<class UGameplayEffect> CooldownGameplayEffectClass; // 0x01C0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer CancelAbilitiesWithTag; // 0x01C8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer BlockAbilitiesWithTag; // 0x01E8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer ActivationOwnedTags; // 0x0208(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer ActivationRequiredTags; // 0x0228(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer ActivationBlockedTags; // 0x0248(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer SourceRequiredTags; // 0x0268(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer SourceBlockedTags; // 0x0288(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer TargetRequiredTags; // 0x02A8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayTagContainer TargetBlockedTags; // 0x02C8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_2E8[0x20]; // 0x02E8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<class UGameplayTask*> ActiveTasks; // 0x0308(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_318[0x10]; // 0x0318(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
|
|
class UAnimMontage* CurrentMontage; // 0x0328(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_330[0x60]; // 0x0330(0x0060)(Fixing Size After Last Property [ Dumper-7 ])
|
|
bool bIsActive; // 0x0390(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bIsAbilityEnding; // 0x0391(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bIsCancelable; // 0x0392(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bIsBlockingOtherAbilities; // 0x0393(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_394[0x14]; // 0x0394(0x0014)(Fixing Size After Last Property [ Dumper-7 ])
|
|
bool bMarkPendingKillOnAbilityEnd; // 0x03A8(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_3A9[0x7]; // 0x03A9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectToOwner(TSubclassOf<class UGameplayEffect> GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks);
|
|
TArray<struct FActiveGameplayEffectHandle> BP_ApplyGameplayEffectToTarget(const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class UGameplayEffect> GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks);
|
|
void BP_RemoveGameplayEffectFromOwnerWithAssetTags(const struct FGameplayTagContainer& WithAssetTags, int32 StacksToRemove);
|
|
void BP_RemoveGameplayEffectFromOwnerWithGrantedTags(const struct FGameplayTagContainer& WithGrantedTags, int32 StacksToRemove);
|
|
void BP_RemoveGameplayEffectFromOwnerWithHandle(const struct FActiveGameplayEffectHandle& Handle, int32 StacksToRemove);
|
|
void CancelTaskByInstanceName(class FName InstanceName);
|
|
void ConfirmTaskByInstanceName(class FName InstanceName, bool bEndTask);
|
|
void EndAbilityState(class FName OptionalStateNameToEnd);
|
|
void EndTaskByInstanceName(class FName InstanceName);
|
|
void K2_ActivateAbility();
|
|
void K2_ActivateAbilityFromEvent(const struct FGameplayEventData& EventData);
|
|
void K2_AddGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context, bool bRemoveOnAbilityEnd);
|
|
void K2_AddGameplayCueWithParams(const struct FGameplayTag& GameplayCueTag, const struct FGameplayCueParameters& GameplayCueParameter, bool bRemoveOnAbilityEnd);
|
|
struct FActiveGameplayEffectHandle K2_ApplyGameplayEffectSpecToOwner(const struct FGameplayEffectSpecHandle& EffectSpecHandle);
|
|
TArray<struct FActiveGameplayEffectHandle> K2_ApplyGameplayEffectSpecToTarget(const struct FGameplayEffectSpecHandle& EffectSpecHandle, const struct FGameplayAbilityTargetDataHandle& TargetData);
|
|
void K2_CancelAbility();
|
|
bool K2_CheckAbilityCooldown();
|
|
bool K2_CheckAbilityCost();
|
|
bool K2_CommitAbility();
|
|
bool K2_CommitAbilityCooldown(bool BroadcastCommitEvent, bool ForceCooldown);
|
|
bool K2_CommitAbilityCost(bool BroadcastCommitEvent);
|
|
void K2_CommitExecute();
|
|
void K2_EndAbility();
|
|
void K2_ExecuteGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context);
|
|
void K2_ExecuteGameplayCueWithParams(const struct FGameplayTag& GameplayCueTag, const struct FGameplayCueParameters& GameplayCueParameters);
|
|
void K2_OnEndAbility(bool bWasCancelled);
|
|
void K2_RemoveGameplayCue(const struct FGameplayTag& GameplayCueTag);
|
|
struct FGameplayAbilityTargetingLocationInfo MakeTargetLocationInfoFromOwnerActor();
|
|
struct FGameplayAbilityTargetingLocationInfo MakeTargetLocationInfoFromOwnerSkeletalMeshComponent(class FName SocketName);
|
|
void MontageJumpToSection(class FName SectionName);
|
|
void MontageSetNextSectionName(class FName FromSectionName, class FName ToSectionName);
|
|
void MontageStop(float OverrideBlendOutTime);
|
|
void RemoveGrantedByEffect();
|
|
void SendGameplayEvent(const struct FGameplayTag& EventTag, const struct FGameplayEventData& Payload);
|
|
void SetCanBeCanceled(bool bCanBeCanceled);
|
|
void SetShouldBlockOtherAbilities(bool bShouldBlockAbilities);
|
|
|
|
int32 GetAbilityLevel() const;
|
|
int32 GetAbilityLevel_BP(const struct FGameplayAbilitySpecHandle& Handle, const struct FGameplayAbilityActorInfo& ActorInfo) const;
|
|
class UAbilitySystemComponent* GetAbilitySystemComponentFromActorInfo() const;
|
|
struct FGameplayAbilityActorInfo GetActorInfo() const;
|
|
class AActor* GetAvatarActorFromActorInfo() const;
|
|
struct FGameplayEffectContextHandle GetContextFromOwner(const struct FGameplayAbilityTargetDataHandle& OptionalTargetData) const;
|
|
float GetCooldownTimeRemaining() const;
|
|
class UAnimMontage* GetCurrentMontage() const;
|
|
class UObject* GetCurrentSourceObject() const;
|
|
struct FGameplayEffectContextHandle GetGrantedByEffectContext() const;
|
|
class AActor* GetOwningActorFromActorInfo() const;
|
|
class USkeletalMeshComponent* GetOwningComponentFromActorInfo() const;
|
|
class UObject* GetSourceObject_BP(const struct FGameplayAbilitySpecHandle& Handle, const struct FGameplayAbilityActorInfo& ActorInfo) const;
|
|
void InvalidateClientPredictionKey() const;
|
|
bool IsLocallyControlled() const;
|
|
bool K2_CanActivateAbility(const struct FGameplayAbilityActorInfo& ActorInfo, const struct FGameplayAbilitySpecHandle& Handle, struct FGameplayTagContainer* RelevantTags) const;
|
|
bool K2_HasAuthority() const;
|
|
bool K2_ShouldAbilityRespondToEvent(const struct FGameplayAbilityActorInfo& ActorInfo, const struct FGameplayEventData& Payload) const;
|
|
struct FGameplayEffectSpecHandle MakeOutgoingGameplayEffectSpec(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level) const;
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbility">();
|
|
}
|
|
static class UGameplayAbility* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayAbility>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayAbility) == 0x000008, "Wrong alignment on UGameplayAbility");
|
|
static_assert(sizeof(UGameplayAbility) == 0x0003B0, "Wrong size on UGameplayAbility");
|
|
static_assert(offsetof(UGameplayAbility, AbilityTags) == 0x0000A8, "Member 'UGameplayAbility::AbilityTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bReplicateInputDirectly) == 0x0000C8, "Member 'UGameplayAbility::bReplicateInputDirectly' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, RemoteInstanceEnded) == 0x0000C9, "Member 'UGameplayAbility::RemoteInstanceEnded' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, ReplicationPolicy) == 0x0000CE, "Member 'UGameplayAbility::ReplicationPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, InstancingPolicy) == 0x0000CF, "Member 'UGameplayAbility::InstancingPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bServerRespectsRemoteAbilityCancellation) == 0x0000D0, "Member 'UGameplayAbility::bServerRespectsRemoteAbilityCancellation' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bRetriggerInstancedAbility) == 0x0000D1, "Member 'UGameplayAbility::bRetriggerInstancedAbility' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, CurrentActivationInfo) == 0x0000D8, "Member 'UGameplayAbility::CurrentActivationInfo' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, CurrentEventData) == 0x0000F0, "Member 'UGameplayAbility::CurrentEventData' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, NetExecutionPolicy) == 0x0001A0, "Member 'UGameplayAbility::NetExecutionPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, NetSecurityPolicy) == 0x0001A1, "Member 'UGameplayAbility::NetSecurityPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, CostGameplayEffectClass) == 0x0001A8, "Member 'UGameplayAbility::CostGameplayEffectClass' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, AbilityTriggers) == 0x0001B0, "Member 'UGameplayAbility::AbilityTriggers' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, CooldownGameplayEffectClass) == 0x0001C0, "Member 'UGameplayAbility::CooldownGameplayEffectClass' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, CancelAbilitiesWithTag) == 0x0001C8, "Member 'UGameplayAbility::CancelAbilitiesWithTag' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, BlockAbilitiesWithTag) == 0x0001E8, "Member 'UGameplayAbility::BlockAbilitiesWithTag' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, ActivationOwnedTags) == 0x000208, "Member 'UGameplayAbility::ActivationOwnedTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, ActivationRequiredTags) == 0x000228, "Member 'UGameplayAbility::ActivationRequiredTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, ActivationBlockedTags) == 0x000248, "Member 'UGameplayAbility::ActivationBlockedTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, SourceRequiredTags) == 0x000268, "Member 'UGameplayAbility::SourceRequiredTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, SourceBlockedTags) == 0x000288, "Member 'UGameplayAbility::SourceBlockedTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, TargetRequiredTags) == 0x0002A8, "Member 'UGameplayAbility::TargetRequiredTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, TargetBlockedTags) == 0x0002C8, "Member 'UGameplayAbility::TargetBlockedTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, ActiveTasks) == 0x000308, "Member 'UGameplayAbility::ActiveTasks' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, CurrentMontage) == 0x000328, "Member 'UGameplayAbility::CurrentMontage' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bIsActive) == 0x000390, "Member 'UGameplayAbility::bIsActive' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bIsAbilityEnding) == 0x000391, "Member 'UGameplayAbility::bIsAbilityEnding' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bIsCancelable) == 0x000392, "Member 'UGameplayAbility::bIsCancelable' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bIsBlockingOtherAbilities) == 0x000393, "Member 'UGameplayAbility::bIsBlockingOtherAbilities' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility, bMarkPendingKillOnAbilityEnd) == 0x0003A8, "Member 'UGameplayAbility::bMarkPendingKillOnAbilityEnd' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbility_CharacterJump
|
|
// 0x0000 (0x03B0 - 0x03B0)
|
|
class UGameplayAbility_CharacterJump final : public UGameplayAbility
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbility_CharacterJump">();
|
|
}
|
|
static class UGameplayAbility_CharacterJump* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayAbility_CharacterJump>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayAbility_CharacterJump) == 0x000008, "Wrong alignment on UGameplayAbility_CharacterJump");
|
|
static_assert(sizeof(UGameplayAbility_CharacterJump) == 0x0003B0, "Wrong size on UGameplayAbility_CharacterJump");
|
|
|
|
// Class GameplayAbilities.GameplayAbility_Montage
|
|
// 0x0038 (0x03E8 - 0x03B0)
|
|
class UGameplayAbility_Montage final : public UGameplayAbility
|
|
{
|
|
public:
|
|
class UAnimMontage* MontageToPlay; // 0x03B0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
float PlayRate; // 0x03B8(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName SectionName; // 0x03BC(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_3C4[0x4]; // 0x03C4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<TSubclassOf<class UGameplayEffect>> GameplayEffectClassesWhileAnimating; // 0x03C8(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
|
|
TArray<class UGameplayEffect*> GameplayEffectsWhileAnimating; // 0x03D8(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, EditConst, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbility_Montage">();
|
|
}
|
|
static class UGameplayAbility_Montage* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayAbility_Montage>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayAbility_Montage) == 0x000008, "Wrong alignment on UGameplayAbility_Montage");
|
|
static_assert(sizeof(UGameplayAbility_Montage) == 0x0003E8, "Wrong size on UGameplayAbility_Montage");
|
|
static_assert(offsetof(UGameplayAbility_Montage, MontageToPlay) == 0x0003B0, "Member 'UGameplayAbility_Montage::MontageToPlay' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility_Montage, PlayRate) == 0x0003B8, "Member 'UGameplayAbility_Montage::PlayRate' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility_Montage, SectionName) == 0x0003BC, "Member 'UGameplayAbility_Montage::SectionName' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility_Montage, GameplayEffectClassesWhileAnimating) == 0x0003C8, "Member 'UGameplayAbility_Montage::GameplayEffectClassesWhileAnimating' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayAbility_Montage, GameplayEffectsWhileAnimating) == 0x0003D8, "Member 'UGameplayAbility_Montage::GameplayEffectsWhileAnimating' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityTargetActor_SingleLineTrace
|
|
// 0x0000 (0x0350 - 0x0350)
|
|
class AGameplayAbilityTargetActor_SingleLineTrace final : public AGameplayAbilityTargetActor_Trace
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityTargetActor_SingleLineTrace">();
|
|
}
|
|
static class AGameplayAbilityTargetActor_SingleLineTrace* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityTargetActor_SingleLineTrace>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayAbilityTargetActor_SingleLineTrace) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_SingleLineTrace");
|
|
static_assert(sizeof(AGameplayAbilityTargetActor_SingleLineTrace) == 0x000350, "Wrong size on AGameplayAbilityTargetActor_SingleLineTrace");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityWorldReticle
|
|
// 0x0020 (0x0240 - 0x0220)
|
|
class AGameplayAbilityWorldReticle : public AActor
|
|
{
|
|
public:
|
|
struct FWorldReticleParameters Parameters; // 0x0220(0x000C)(Edit, BlueprintVisible, DisableEditOnTemplate, NoDestructor, ExposeOnSpawn, NativeAccessSpecifierPublic)
|
|
bool bFaceOwnerFlat; // 0x022C(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bSnapToTargetedActor; // 0x022D(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bIsTargetValid; // 0x022E(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
bool bIsTargetAnActor; // 0x022F(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class APlayerController* MasterPC; // 0x0230(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
class AActor* TargetingActor; // 0x0238(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
|
|
public:
|
|
void FaceTowardSource(bool bFaceIn2D);
|
|
void OnParametersInitialized();
|
|
void OnTargetingAnActor(bool bNewValue);
|
|
void OnValidTargetChanged(bool bNewValue);
|
|
void SetReticleMaterialParamFloat(class FName ParamName, float Value);
|
|
void SetReticleMaterialParamVector(class FName ParamName, const struct FVector& Value);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityWorldReticle">();
|
|
}
|
|
static class AGameplayAbilityWorldReticle* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityWorldReticle>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayAbilityWorldReticle) == 0x000008, "Wrong alignment on AGameplayAbilityWorldReticle");
|
|
static_assert(sizeof(AGameplayAbilityWorldReticle) == 0x000240, "Wrong size on AGameplayAbilityWorldReticle");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle, Parameters) == 0x000220, "Member 'AGameplayAbilityWorldReticle::Parameters' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle, bFaceOwnerFlat) == 0x00022C, "Member 'AGameplayAbilityWorldReticle::bFaceOwnerFlat' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle, bSnapToTargetedActor) == 0x00022D, "Member 'AGameplayAbilityWorldReticle::bSnapToTargetedActor' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle, bIsTargetValid) == 0x00022E, "Member 'AGameplayAbilityWorldReticle::bIsTargetValid' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle, bIsTargetAnActor) == 0x00022F, "Member 'AGameplayAbilityWorldReticle::bIsTargetAnActor' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle, MasterPC) == 0x000230, "Member 'AGameplayAbilityWorldReticle::MasterPC' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle, TargetingActor) == 0x000238, "Member 'AGameplayAbilityWorldReticle::TargetingActor' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayAbilityWorldReticle_ActorVisualization
|
|
// 0x0018 (0x0258 - 0x0240)
|
|
class AGameplayAbilityWorldReticle_ActorVisualization final : public AGameplayAbilityWorldReticle
|
|
{
|
|
public:
|
|
class UCapsuleComponent* CollisionComponent; // 0x0240(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
|
|
TArray<class UActorComponent*> VisualizationComponents; // 0x0248(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayAbilityWorldReticle_ActorVisualization">();
|
|
}
|
|
static class AGameplayAbilityWorldReticle_ActorVisualization* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayAbilityWorldReticle_ActorVisualization>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayAbilityWorldReticle_ActorVisualization) == 0x000008, "Wrong alignment on AGameplayAbilityWorldReticle_ActorVisualization");
|
|
static_assert(sizeof(AGameplayAbilityWorldReticle_ActorVisualization) == 0x000258, "Wrong size on AGameplayAbilityWorldReticle_ActorVisualization");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle_ActorVisualization, CollisionComponent) == 0x000240, "Member 'AGameplayAbilityWorldReticle_ActorVisualization::CollisionComponent' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayAbilityWorldReticle_ActorVisualization, VisualizationComponents) == 0x000248, "Member 'AGameplayAbilityWorldReticle_ActorVisualization::VisualizationComponents' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayCueInterface
|
|
// 0x0000 (0x0000 - 0x0000)
|
|
class IGameplayCueInterface final
|
|
{
|
|
public:
|
|
void BlueprintCustomHandler(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters);
|
|
void ForwardGameplayCueToParent();
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueInterface">();
|
|
}
|
|
static class IGameplayCueInterface* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<IGameplayCueInterface>();
|
|
}
|
|
|
|
class UObject* AsUObject()
|
|
{
|
|
return reinterpret_cast<UObject*>(this);
|
|
}
|
|
const class UObject* AsUObject() const
|
|
{
|
|
return reinterpret_cast<const UObject*>(this);
|
|
}
|
|
};
|
|
static_assert(alignof(IGameplayCueInterface) == 0x000001, "Wrong alignment on IGameplayCueInterface");
|
|
static_assert(sizeof(IGameplayCueInterface) == 0x000001, "Wrong size on IGameplayCueInterface");
|
|
|
|
// Class GameplayAbilities.GameplayCueManager
|
|
// 0x02E0 (0x0310 - 0x0030)
|
|
class UGameplayCueManager final : public UDataAsset
|
|
{
|
|
public:
|
|
uint8 Pad_30[0x18]; // 0x0030(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayCueObjectLibrary RuntimeGameplayCueObjectLibrary; // 0x0048(0x0050)(Transient, Protected, NativeAccessSpecifierProtected)
|
|
struct FGameplayCueObjectLibrary EditorGameplayCueObjectLibrary; // 0x0098(0x0050)(Transient, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_E8[0x1C8]; // 0x00E8(0x01C8)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<class UClass*> LoadedGameplayCueNotifyClasses; // 0x02B0(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
|
|
TArray<TSubclassOf<class AGameplayCueNotify_Actor>> GameplayCueClassesForPreallocation; // 0x02C0(0x0010)(ZeroConstructor, Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
|
|
TArray<struct FGameplayCuePendingExecute> PendingExecuteCues; // 0x02D0(0x0010)(ZeroConstructor, Transient, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
|
|
int32 GameplayCueSendContextCount; // 0x02E0(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_2E4[0x4]; // 0x02E4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<struct FPreallocationInfo> PreallocationInfoList_Internal; // 0x02E8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
|
|
uint8 Pad_2F8[0x18]; // 0x02F8(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueManager">();
|
|
}
|
|
static class UGameplayCueManager* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayCueManager>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayCueManager) == 0x000008, "Wrong alignment on UGameplayCueManager");
|
|
static_assert(sizeof(UGameplayCueManager) == 0x000310, "Wrong size on UGameplayCueManager");
|
|
static_assert(offsetof(UGameplayCueManager, RuntimeGameplayCueObjectLibrary) == 0x000048, "Member 'UGameplayCueManager::RuntimeGameplayCueObjectLibrary' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueManager, EditorGameplayCueObjectLibrary) == 0x000098, "Member 'UGameplayCueManager::EditorGameplayCueObjectLibrary' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueManager, LoadedGameplayCueNotifyClasses) == 0x0002B0, "Member 'UGameplayCueManager::LoadedGameplayCueNotifyClasses' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueManager, GameplayCueClassesForPreallocation) == 0x0002C0, "Member 'UGameplayCueManager::GameplayCueClassesForPreallocation' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueManager, PendingExecuteCues) == 0x0002D0, "Member 'UGameplayCueManager::PendingExecuteCues' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueManager, GameplayCueSendContextCount) == 0x0002E0, "Member 'UGameplayCueManager::GameplayCueSendContextCount' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueManager, PreallocationInfoList_Internal) == 0x0002E8, "Member 'UGameplayCueManager::PreallocationInfoList_Internal' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayCueNotify_Actor
|
|
// 0x0060 (0x0280 - 0x0220)
|
|
class AGameplayCueNotify_Actor final : public AActor
|
|
{
|
|
public:
|
|
bool bAutoDestroyOnRemove; // 0x0220(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_221[0x3]; // 0x0221(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
|
|
float AutoDestroyDelay; // 0x0224(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool WarnIfTimelineIsStillRunning; // 0x0228(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool WarnIfLatentActionIsStillRunning; // 0x0229(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_22A[0x2]; // 0x022A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayTag GameplayCueTag; // 0x022C(0x0008)(Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName GameplayCueName; // 0x0234(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bAutoAttachToOwner; // 0x023C(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool IsOverride; // 0x023D(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bUniqueInstancePerInstigator; // 0x023E(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bUniqueInstancePerSourceObject; // 0x023F(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bAllowMultipleOnActiveEvents; // 0x0240(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bAllowMultipleWhileActiveEvents; // 0x0241(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_242[0x2]; // 0x0242(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
|
|
int32 NumPreallocatedInstances; // 0x0244(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_248[0x38]; // 0x0248(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void K2_EndGameplayCue();
|
|
void K2_HandleGameplayCue(class AActor* MyTarget, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters);
|
|
bool OnActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);
|
|
bool OnExecute(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);
|
|
void OnOwnerDestroyed(class AActor* DestroyedActor);
|
|
bool OnRemove(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);
|
|
bool WhileActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueNotify_Actor">();
|
|
}
|
|
static class AGameplayCueNotify_Actor* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<AGameplayCueNotify_Actor>();
|
|
}
|
|
};
|
|
static_assert(alignof(AGameplayCueNotify_Actor) == 0x000008, "Wrong alignment on AGameplayCueNotify_Actor");
|
|
static_assert(sizeof(AGameplayCueNotify_Actor) == 0x000280, "Wrong size on AGameplayCueNotify_Actor");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, bAutoDestroyOnRemove) == 0x000220, "Member 'AGameplayCueNotify_Actor::bAutoDestroyOnRemove' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, AutoDestroyDelay) == 0x000224, "Member 'AGameplayCueNotify_Actor::AutoDestroyDelay' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, WarnIfTimelineIsStillRunning) == 0x000228, "Member 'AGameplayCueNotify_Actor::WarnIfTimelineIsStillRunning' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, WarnIfLatentActionIsStillRunning) == 0x000229, "Member 'AGameplayCueNotify_Actor::WarnIfLatentActionIsStillRunning' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, GameplayCueTag) == 0x00022C, "Member 'AGameplayCueNotify_Actor::GameplayCueTag' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, GameplayCueName) == 0x000234, "Member 'AGameplayCueNotify_Actor::GameplayCueName' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, bAutoAttachToOwner) == 0x00023C, "Member 'AGameplayCueNotify_Actor::bAutoAttachToOwner' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, IsOverride) == 0x00023D, "Member 'AGameplayCueNotify_Actor::IsOverride' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, bUniqueInstancePerInstigator) == 0x00023E, "Member 'AGameplayCueNotify_Actor::bUniqueInstancePerInstigator' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, bUniqueInstancePerSourceObject) == 0x00023F, "Member 'AGameplayCueNotify_Actor::bUniqueInstancePerSourceObject' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, bAllowMultipleOnActiveEvents) == 0x000240, "Member 'AGameplayCueNotify_Actor::bAllowMultipleOnActiveEvents' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, bAllowMultipleWhileActiveEvents) == 0x000241, "Member 'AGameplayCueNotify_Actor::bAllowMultipleWhileActiveEvents' has a wrong offset!");
|
|
static_assert(offsetof(AGameplayCueNotify_Actor, NumPreallocatedInstances) == 0x000244, "Member 'AGameplayCueNotify_Actor::NumPreallocatedInstances' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayCueNotify_Static
|
|
// 0x0018 (0x0040 - 0x0028)
|
|
class UGameplayCueNotify_Static : public UObject
|
|
{
|
|
public:
|
|
struct FGameplayTag GameplayCueTag; // 0x0028(0x0008)(Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class FName GameplayCueName; // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool IsOverride; // 0x0038(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_39[0x7]; // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void K2_HandleGameplayCue(class AActor* MyTarget, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters) const;
|
|
bool OnActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;
|
|
bool OnExecute(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;
|
|
bool OnRemove(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;
|
|
bool WhileActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueNotify_Static">();
|
|
}
|
|
static class UGameplayCueNotify_Static* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayCueNotify_Static>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayCueNotify_Static) == 0x000008, "Wrong alignment on UGameplayCueNotify_Static");
|
|
static_assert(sizeof(UGameplayCueNotify_Static) == 0x000040, "Wrong size on UGameplayCueNotify_Static");
|
|
static_assert(offsetof(UGameplayCueNotify_Static, GameplayCueTag) == 0x000028, "Member 'UGameplayCueNotify_Static::GameplayCueTag' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueNotify_Static, GameplayCueName) == 0x000030, "Member 'UGameplayCueNotify_Static::GameplayCueName' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueNotify_Static, IsOverride) == 0x000038, "Member 'UGameplayCueNotify_Static::IsOverride' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayCueNotify_HitImpact
|
|
// 0x0010 (0x0050 - 0x0040)
|
|
class UGameplayCueNotify_HitImpact final : public UGameplayCueNotify_Static
|
|
{
|
|
public:
|
|
class USoundBase* Sound; // 0x0040(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
class UParticleSystem* ParticleSystem; // 0x0048(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueNotify_HitImpact">();
|
|
}
|
|
static class UGameplayCueNotify_HitImpact* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayCueNotify_HitImpact>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayCueNotify_HitImpact) == 0x000008, "Wrong alignment on UGameplayCueNotify_HitImpact");
|
|
static_assert(sizeof(UGameplayCueNotify_HitImpact) == 0x000050, "Wrong size on UGameplayCueNotify_HitImpact");
|
|
static_assert(offsetof(UGameplayCueNotify_HitImpact, Sound) == 0x000040, "Member 'UGameplayCueNotify_HitImpact::Sound' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayCueNotify_HitImpact, ParticleSystem) == 0x000048, "Member 'UGameplayCueNotify_HitImpact::ParticleSystem' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayCueSet
|
|
// 0x0060 (0x0090 - 0x0030)
|
|
class UGameplayCueSet final : public UDataAsset
|
|
{
|
|
public:
|
|
TArray<struct FGameplayCueNotifyData> GameplayCueData; // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
uint8 Pad_40[0x50]; // 0x0040(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueSet">();
|
|
}
|
|
static class UGameplayCueSet* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayCueSet>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayCueSet) == 0x000008, "Wrong alignment on UGameplayCueSet");
|
|
static_assert(sizeof(UGameplayCueSet) == 0x000090, "Wrong size on UGameplayCueSet");
|
|
static_assert(offsetof(UGameplayCueSet, GameplayCueData) == 0x000030, "Member 'UGameplayCueSet::GameplayCueData' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayCueTranslator
|
|
// 0x0000 (0x0028 - 0x0028)
|
|
class UGameplayCueTranslator : public UObject
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueTranslator">();
|
|
}
|
|
static class UGameplayCueTranslator* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayCueTranslator>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayCueTranslator) == 0x000008, "Wrong alignment on UGameplayCueTranslator");
|
|
static_assert(sizeof(UGameplayCueTranslator) == 0x000028, "Wrong size on UGameplayCueTranslator");
|
|
|
|
// Class GameplayAbilities.GameplayCueTranslator_Test
|
|
// 0x0000 (0x0028 - 0x0028)
|
|
class UGameplayCueTranslator_Test final : public UGameplayCueTranslator
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayCueTranslator_Test">();
|
|
}
|
|
static class UGameplayCueTranslator_Test* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayCueTranslator_Test>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayCueTranslator_Test) == 0x000008, "Wrong alignment on UGameplayCueTranslator_Test");
|
|
static_assert(sizeof(UGameplayCueTranslator_Test) == 0x000028, "Wrong size on UGameplayCueTranslator_Test");
|
|
|
|
// Class GameplayAbilities.GameplayEffect
|
|
// 0x07D8 (0x0800 - 0x0028)
|
|
class UGameplayEffect final : public UObject
|
|
{
|
|
public:
|
|
uint8 Pad_28[0x8]; // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
|
|
EGameplayEffectDurationType DurationPolicy; // 0x0030(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_31[0x7]; // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayEffectModifierMagnitude DurationMagnitude; // 0x0038(0x01E0)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FScalableFloat Period; // 0x0218(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
bool bExecutePeriodicEffectOnApplication; // 0x0240(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
EGameplayEffectPeriodInhibitionRemovedPolicy PeriodicInhibitionPolicy; // 0x0241(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_242[0x6]; // 0x0242(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<struct FGameplayModifierInfo> Modifiers; // 0x0248(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
TArray<struct FGameplayEffectExecutionDefinition> Executions; // 0x0258(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FScalableFloat ChanceToApplyToTarget; // 0x0268(0x0028)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
TArray<TSubclassOf<class UGameplayEffectCustomApplicationRequirement>> ApplicationRequirements; // 0x0290(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
|
|
TArray<TSubclassOf<class UGameplayEffect>> TargetEffectClasses; // 0x02A0(0x0010)(ZeroConstructor, Deprecated, UObjectWrapper, NativeAccessSpecifierPublic)
|
|
TArray<struct FConditionalGameplayEffect> ConditionalGameplayEffects; // 0x02B0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
TArray<TSubclassOf<class UGameplayEffect>> OverflowEffects; // 0x02C0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
|
|
bool bDenyOverflowApplication; // 0x02D0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bClearStackOnOverflow; // 0x02D1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_2D2[0x6]; // 0x02D2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<TSubclassOf<class UGameplayEffect>> PrematureExpirationEffectClasses; // 0x02D8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
|
|
TArray<TSubclassOf<class UGameplayEffect>> RoutineExpirationEffectClasses; // 0x02E8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
|
|
bool bRequireModifierSuccessToTriggerCues; // 0x02F8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
bool bSuppressStackingCues; // 0x02F9(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_2FA[0x6]; // 0x02FA(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<struct FGameplayEffectCue> GameplayCues; // 0x0300(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
class UGameplayEffectUIData* UIData; // 0x0310(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
struct FInheritedTagContainer InheritableGameplayEffectTags; // 0x0318(0x0060)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FInheritedTagContainer InheritableOwnedTagsContainer; // 0x0378(0x0060)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FGameplayTagRequirements OngoingTagRequirements; // 0x03D8(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FGameplayTagRequirements ApplicationTagRequirements; // 0x0418(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FGameplayTagRequirements RemovalTagRequirements; // 0x0458(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FInheritedTagContainer RemoveGameplayEffectsWithTags; // 0x0498(0x0060)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FGameplayTagRequirements GrantedApplicationImmunityTags; // 0x04F8(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
struct FGameplayEffectQuery GrantedApplicationImmunityQuery; // 0x0538(0x0150)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
uint8 Pad_688[0x8]; // 0x0688(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
|
|
struct FGameplayEffectQuery RemoveGameplayEffectQuery; // 0x0690(0x0150)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
uint8 Pad_7E0[0x1]; // 0x07E0(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
|
|
EGameplayEffectStackingType StackingType; // 0x07E1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_7E2[0x2]; // 0x07E2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
|
|
int32 StackLimitCount; // 0x07E4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
EGameplayEffectStackingDurationPolicy StackDurationRefreshPolicy; // 0x07E8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
EGameplayEffectStackingPeriodPolicy StackPeriodResetPolicy; // 0x07E9(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
EGameplayEffectStackingExpirationPolicy StackExpirationPolicy; // 0x07EA(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
uint8 Pad_7EB[0x5]; // 0x07EB(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
|
|
TArray<struct FGameplayAbilitySpecDef> GrantedAbilities; // 0x07F0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayEffect">();
|
|
}
|
|
static class UGameplayEffect* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayEffect>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayEffect) == 0x000008, "Wrong alignment on UGameplayEffect");
|
|
static_assert(sizeof(UGameplayEffect) == 0x000800, "Wrong size on UGameplayEffect");
|
|
static_assert(offsetof(UGameplayEffect, DurationPolicy) == 0x000030, "Member 'UGameplayEffect::DurationPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, DurationMagnitude) == 0x000038, "Member 'UGameplayEffect::DurationMagnitude' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, Period) == 0x000218, "Member 'UGameplayEffect::Period' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, bExecutePeriodicEffectOnApplication) == 0x000240, "Member 'UGameplayEffect::bExecutePeriodicEffectOnApplication' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, PeriodicInhibitionPolicy) == 0x000241, "Member 'UGameplayEffect::PeriodicInhibitionPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, Modifiers) == 0x000248, "Member 'UGameplayEffect::Modifiers' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, Executions) == 0x000258, "Member 'UGameplayEffect::Executions' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, ChanceToApplyToTarget) == 0x000268, "Member 'UGameplayEffect::ChanceToApplyToTarget' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, ApplicationRequirements) == 0x000290, "Member 'UGameplayEffect::ApplicationRequirements' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, TargetEffectClasses) == 0x0002A0, "Member 'UGameplayEffect::TargetEffectClasses' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, ConditionalGameplayEffects) == 0x0002B0, "Member 'UGameplayEffect::ConditionalGameplayEffects' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, OverflowEffects) == 0x0002C0, "Member 'UGameplayEffect::OverflowEffects' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, bDenyOverflowApplication) == 0x0002D0, "Member 'UGameplayEffect::bDenyOverflowApplication' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, bClearStackOnOverflow) == 0x0002D1, "Member 'UGameplayEffect::bClearStackOnOverflow' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, PrematureExpirationEffectClasses) == 0x0002D8, "Member 'UGameplayEffect::PrematureExpirationEffectClasses' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, RoutineExpirationEffectClasses) == 0x0002E8, "Member 'UGameplayEffect::RoutineExpirationEffectClasses' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, bRequireModifierSuccessToTriggerCues) == 0x0002F8, "Member 'UGameplayEffect::bRequireModifierSuccessToTriggerCues' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, bSuppressStackingCues) == 0x0002F9, "Member 'UGameplayEffect::bSuppressStackingCues' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, GameplayCues) == 0x000300, "Member 'UGameplayEffect::GameplayCues' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, UIData) == 0x000310, "Member 'UGameplayEffect::UIData' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, InheritableGameplayEffectTags) == 0x000318, "Member 'UGameplayEffect::InheritableGameplayEffectTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, InheritableOwnedTagsContainer) == 0x000378, "Member 'UGameplayEffect::InheritableOwnedTagsContainer' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, OngoingTagRequirements) == 0x0003D8, "Member 'UGameplayEffect::OngoingTagRequirements' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, ApplicationTagRequirements) == 0x000418, "Member 'UGameplayEffect::ApplicationTagRequirements' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, RemovalTagRequirements) == 0x000458, "Member 'UGameplayEffect::RemovalTagRequirements' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, RemoveGameplayEffectsWithTags) == 0x000498, "Member 'UGameplayEffect::RemoveGameplayEffectsWithTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, GrantedApplicationImmunityTags) == 0x0004F8, "Member 'UGameplayEffect::GrantedApplicationImmunityTags' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, GrantedApplicationImmunityQuery) == 0x000538, "Member 'UGameplayEffect::GrantedApplicationImmunityQuery' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, RemoveGameplayEffectQuery) == 0x000690, "Member 'UGameplayEffect::RemoveGameplayEffectQuery' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, StackingType) == 0x0007E1, "Member 'UGameplayEffect::StackingType' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, StackLimitCount) == 0x0007E4, "Member 'UGameplayEffect::StackLimitCount' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, StackDurationRefreshPolicy) == 0x0007E8, "Member 'UGameplayEffect::StackDurationRefreshPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, StackPeriodResetPolicy) == 0x0007E9, "Member 'UGameplayEffect::StackPeriodResetPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, StackExpirationPolicy) == 0x0007EA, "Member 'UGameplayEffect::StackExpirationPolicy' has a wrong offset!");
|
|
static_assert(offsetof(UGameplayEffect, GrantedAbilities) == 0x0007F0, "Member 'UGameplayEffect::GrantedAbilities' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayEffectCalculation
|
|
// 0x0010 (0x0038 - 0x0028)
|
|
class UGameplayEffectCalculation : public UObject
|
|
{
|
|
public:
|
|
TArray<struct FGameplayEffectAttributeCaptureDefinition> RelevantAttributesToCapture; // 0x0028(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayEffectCalculation">();
|
|
}
|
|
static class UGameplayEffectCalculation* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayEffectCalculation>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayEffectCalculation) == 0x000008, "Wrong alignment on UGameplayEffectCalculation");
|
|
static_assert(sizeof(UGameplayEffectCalculation) == 0x000038, "Wrong size on UGameplayEffectCalculation");
|
|
static_assert(offsetof(UGameplayEffectCalculation, RelevantAttributesToCapture) == 0x000028, "Member 'UGameplayEffectCalculation::RelevantAttributesToCapture' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayEffectCustomApplicationRequirement
|
|
// 0x0000 (0x0028 - 0x0028)
|
|
class UGameplayEffectCustomApplicationRequirement final : public UObject
|
|
{
|
|
public:
|
|
bool CanApplyGameplayEffect(const class UGameplayEffect* GameplayEffect, const struct FGameplayEffectSpec& Spec, class UAbilitySystemComponent* ASC) const;
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayEffectCustomApplicationRequirement">();
|
|
}
|
|
static class UGameplayEffectCustomApplicationRequirement* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayEffectCustomApplicationRequirement>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayEffectCustomApplicationRequirement) == 0x000008, "Wrong alignment on UGameplayEffectCustomApplicationRequirement");
|
|
static_assert(sizeof(UGameplayEffectCustomApplicationRequirement) == 0x000028, "Wrong size on UGameplayEffectCustomApplicationRequirement");
|
|
|
|
// Class GameplayAbilities.GameplayEffectExecutionCalculation
|
|
// 0x0008 (0x0040 - 0x0038)
|
|
class UGameplayEffectExecutionCalculation final : public UGameplayEffectCalculation
|
|
{
|
|
public:
|
|
bool bRequiresPassedInTags; // 0x0038(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_39[0x7]; // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void Execute(const struct FGameplayEffectCustomExecutionParameters& ExecutionParams, struct FGameplayEffectCustomExecutionOutput* OutExecutionOutput) const;
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayEffectExecutionCalculation">();
|
|
}
|
|
static class UGameplayEffectExecutionCalculation* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayEffectExecutionCalculation>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayEffectExecutionCalculation) == 0x000008, "Wrong alignment on UGameplayEffectExecutionCalculation");
|
|
static_assert(sizeof(UGameplayEffectExecutionCalculation) == 0x000040, "Wrong size on UGameplayEffectExecutionCalculation");
|
|
static_assert(offsetof(UGameplayEffectExecutionCalculation, bRequiresPassedInTags) == 0x000038, "Member 'UGameplayEffectExecutionCalculation::bRequiresPassedInTags' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayEffectUIData
|
|
// 0x0000 (0x0028 - 0x0028)
|
|
class UGameplayEffectUIData : public UObject
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayEffectUIData">();
|
|
}
|
|
static class UGameplayEffectUIData* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayEffectUIData>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayEffectUIData) == 0x000008, "Wrong alignment on UGameplayEffectUIData");
|
|
static_assert(sizeof(UGameplayEffectUIData) == 0x000028, "Wrong size on UGameplayEffectUIData");
|
|
|
|
// Class GameplayAbilities.GameplayEffectUIData_TextOnly
|
|
// 0x0018 (0x0040 - 0x0028)
|
|
class UGameplayEffectUIData_TextOnly final : public UGameplayEffectUIData
|
|
{
|
|
public:
|
|
class FText Description; // 0x0028(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayEffectUIData_TextOnly">();
|
|
}
|
|
static class UGameplayEffectUIData_TextOnly* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayEffectUIData_TextOnly>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayEffectUIData_TextOnly) == 0x000008, "Wrong alignment on UGameplayEffectUIData_TextOnly");
|
|
static_assert(sizeof(UGameplayEffectUIData_TextOnly) == 0x000040, "Wrong size on UGameplayEffectUIData_TextOnly");
|
|
static_assert(offsetof(UGameplayEffectUIData_TextOnly, Description) == 0x000028, "Member 'UGameplayEffectUIData_TextOnly::Description' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayModMagnitudeCalculation
|
|
// 0x0008 (0x0040 - 0x0038)
|
|
class UGameplayModMagnitudeCalculation final : public UGameplayEffectCalculation
|
|
{
|
|
public:
|
|
bool bAllowNonNetAuthorityDependencyRegistration; // 0x0038(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
uint8 Pad_39[0x7]; // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
float CalculateBaseMagnitude(const struct FGameplayEffectSpec& Spec) const;
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayModMagnitudeCalculation">();
|
|
}
|
|
static class UGameplayModMagnitudeCalculation* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayModMagnitudeCalculation>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayModMagnitudeCalculation) == 0x000008, "Wrong alignment on UGameplayModMagnitudeCalculation");
|
|
static_assert(sizeof(UGameplayModMagnitudeCalculation) == 0x000040, "Wrong size on UGameplayModMagnitudeCalculation");
|
|
static_assert(offsetof(UGameplayModMagnitudeCalculation, bAllowNonNetAuthorityDependencyRegistration) == 0x000038, "Member 'UGameplayModMagnitudeCalculation::bAllowNonNetAuthorityDependencyRegistration' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.GameplayTagReponseTable
|
|
// 0x01B8 (0x01E8 - 0x0030)
|
|
class UGameplayTagReponseTable final : public UDataAsset
|
|
{
|
|
public:
|
|
TArray<struct FGameplayTagResponseTableEntry> Entries; // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
uint8 Pad_40[0x1A8]; // 0x0040(0x01A8)(Fixing Struct Size After Last Property [ Dumper-7 ])
|
|
|
|
public:
|
|
void TagResponseEvent(const struct FGameplayTag& Tag, int32 NewCount, class UAbilitySystemComponent* ASC, int32 idx);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"GameplayTagReponseTable">();
|
|
}
|
|
static class UGameplayTagReponseTable* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UGameplayTagReponseTable>();
|
|
}
|
|
};
|
|
static_assert(alignof(UGameplayTagReponseTable) == 0x000008, "Wrong alignment on UGameplayTagReponseTable");
|
|
static_assert(sizeof(UGameplayTagReponseTable) == 0x0001E8, "Wrong size on UGameplayTagReponseTable");
|
|
static_assert(offsetof(UGameplayTagReponseTable, Entries) == 0x000030, "Member 'UGameplayTagReponseTable::Entries' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.MovieSceneGameplayCueTriggerSection
|
|
// 0x0088 (0x0188 - 0x0100)
|
|
class UMovieSceneGameplayCueTriggerSection final : public UMovieSceneHookSection
|
|
{
|
|
public:
|
|
struct FMovieSceneGameplayCueChannel Channel; // 0x0100(0x0088)(AssetRegistrySearchable, NativeAccessSpecifierPrivate)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"MovieSceneGameplayCueTriggerSection">();
|
|
}
|
|
static class UMovieSceneGameplayCueTriggerSection* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UMovieSceneGameplayCueTriggerSection>();
|
|
}
|
|
};
|
|
static_assert(alignof(UMovieSceneGameplayCueTriggerSection) == 0x000008, "Wrong alignment on UMovieSceneGameplayCueTriggerSection");
|
|
static_assert(sizeof(UMovieSceneGameplayCueTriggerSection) == 0x000188, "Wrong size on UMovieSceneGameplayCueTriggerSection");
|
|
static_assert(offsetof(UMovieSceneGameplayCueTriggerSection, Channel) == 0x000100, "Member 'UMovieSceneGameplayCueTriggerSection::Channel' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.MovieSceneGameplayCueSection
|
|
// 0x0078 (0x0178 - 0x0100)
|
|
class UMovieSceneGameplayCueSection final : public UMovieSceneHookSection
|
|
{
|
|
public:
|
|
struct FMovieSceneGameplayCueKey Cue; // 0x0100(0x0078)(Edit, NoDestructor, AssetRegistrySearchable, NativeAccessSpecifierPrivate)
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"MovieSceneGameplayCueSection">();
|
|
}
|
|
static class UMovieSceneGameplayCueSection* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UMovieSceneGameplayCueSection>();
|
|
}
|
|
};
|
|
static_assert(alignof(UMovieSceneGameplayCueSection) == 0x000008, "Wrong alignment on UMovieSceneGameplayCueSection");
|
|
static_assert(sizeof(UMovieSceneGameplayCueSection) == 0x000178, "Wrong size on UMovieSceneGameplayCueSection");
|
|
static_assert(offsetof(UMovieSceneGameplayCueSection, Cue) == 0x000100, "Member 'UMovieSceneGameplayCueSection::Cue' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.MovieSceneGameplayCueTrack
|
|
// 0x0010 (0x00A0 - 0x0090)
|
|
class UMovieSceneGameplayCueTrack final : public UMovieSceneNameableTrack
|
|
{
|
|
public:
|
|
TArray<class UMovieSceneSection*> Sections; // 0x0090(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
|
|
|
|
public:
|
|
static void SetSequencerTrackHandler(TDelegate<void(class AActor* Target, const struct FGameplayTag& GameplayTag, const struct FGameplayCueParameters& Parameters, EGameplayCueEvent Event)> InGameplayCueTrackHandler);
|
|
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"MovieSceneGameplayCueTrack">();
|
|
}
|
|
static class UMovieSceneGameplayCueTrack* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<UMovieSceneGameplayCueTrack>();
|
|
}
|
|
};
|
|
static_assert(alignof(UMovieSceneGameplayCueTrack) == 0x000008, "Wrong alignment on UMovieSceneGameplayCueTrack");
|
|
static_assert(sizeof(UMovieSceneGameplayCueTrack) == 0x0000A0, "Wrong size on UMovieSceneGameplayCueTrack");
|
|
static_assert(offsetof(UMovieSceneGameplayCueTrack, Sections) == 0x000090, "Member 'UMovieSceneGameplayCueTrack::Sections' has a wrong offset!");
|
|
|
|
// Class GameplayAbilities.TickableAttributeSetInterface
|
|
// 0x0000 (0x0000 - 0x0000)
|
|
class ITickableAttributeSetInterface final
|
|
{
|
|
public:
|
|
static class UClass* StaticClass()
|
|
{
|
|
return StaticClassImpl<"TickableAttributeSetInterface">();
|
|
}
|
|
static class ITickableAttributeSetInterface* GetDefaultObj()
|
|
{
|
|
return GetDefaultObjImpl<ITickableAttributeSetInterface>();
|
|
}
|
|
|
|
class UObject* AsUObject()
|
|
{
|
|
return reinterpret_cast<UObject*>(this);
|
|
}
|
|
const class UObject* AsUObject() const
|
|
{
|
|
return reinterpret_cast<const UObject*>(this);
|
|
}
|
|
};
|
|
static_assert(alignof(ITickableAttributeSetInterface) == 0x000001, "Wrong alignment on ITickableAttributeSetInterface");
|
|
static_assert(sizeof(ITickableAttributeSetInterface) == 0x000001, "Wrong size on ITickableAttributeSetInterface");
|
|
|
|
}
|
|
|