mirror of
https://github.com/ApfelTeeSaft/Alphanium.git
synced 2026-08-27 11:43:28 +00:00
7357 lines
309 KiB
C++
7357 lines
309 KiB
C++
#pragma once
|
|
|
|
/*
|
|
* SDK generated by Dumper-7
|
|
*
|
|
* https://github.com/Encryqed/Dumper-7
|
|
*/
|
|
|
|
// Package: GameplayAbilities
|
|
|
|
#include "Basic.hpp"
|
|
|
|
#include "GameplayAbilities_classes.hpp"
|
|
#include "GameplayAbilities_parameters.hpp"
|
|
|
|
|
|
#pragma pack(push, 0x4)
|
|
namespace SDK
|
|
{
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEffectRemoved.WaitForGameplayEffectRemoved
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FActiveGameplayEffectHandle&Handle (Parm, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitGameplayEffectRemoved*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitGameplayEffectRemoved* UAbilityTask_WaitGameplayEffectRemoved::WaitForGameplayEffectRemoved(class UObject* WorldContextObject, const struct FActiveGameplayEffectHandle& Handle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitGameplayEffectRemoved", "WaitForGameplayEffectRemoved");
|
|
|
|
Params::AbilityTask_WaitGameplayEffectRemoved_WaitForGameplayEffectRemoved Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Handle = std::move(Handle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEffectRemoved.OnGameplayEffectRemoved
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitGameplayEffectRemoved::OnGameplayEffectRemoved()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitGameplayEffectRemoved", "OnGameplayEffectRemoved");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Static.K2_HandleGameplayCue
|
|
// (Event, Public, HasOutParams, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EGameplayCueEvent EventType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayCueNotify_Static::K2_HandleGameplayCue(class AActor* MyTarget, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Static", "K2_HandleGameplayCue");
|
|
|
|
Params::GameplayCueNotify_Static_K2_HandleGameplayCue Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.EventType = EventType;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Static.OnActive
|
|
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayCueNotify_Static::OnActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Static", "OnActive");
|
|
|
|
Params::GameplayCueNotify_Static_OnActive Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Static.OnExecute
|
|
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayCueNotify_Static::OnExecute(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Static", "OnExecute");
|
|
|
|
Params::GameplayCueNotify_Static_OnExecute Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Static.OnRemove
|
|
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayCueNotify_Static::OnRemove(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Static", "OnRemove");
|
|
|
|
Params::GameplayCueNotify_Static_OnRemove Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Static.WhileActive
|
|
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayCueNotify_Static::WhileActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Static", "WhileActive");
|
|
|
|
Params::GameplayCueNotify_Static_WhileActive Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitAttributeChange.WaitForAttributeChange
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& Attribute (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& WithSrcTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& WithoutSrcTag (Parm, NativeAccessSpecifierPublic)
|
|
// bool TriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitAttributeChange* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitAttributeChange* UAbilityTask_WaitAttributeChange::WaitForAttributeChange(class UObject* WorldContextObject, const struct FGameplayAttribute& Attribute, const struct FGameplayTag& WithSrcTag, const struct FGameplayTag& WithoutSrcTag, bool TriggerOnce)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitAttributeChange", "WaitForAttributeChange");
|
|
|
|
Params::AbilityTask_WaitAttributeChange_WaitForAttributeChange Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Attribute = std::move(Attribute);
|
|
Parms.WithSrcTag = std::move(WithSrcTag);
|
|
Parms.WithoutSrcTag = std::move(WithoutSrcTag);
|
|
Parms.TriggerOnce = TriggerOnce;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitAttributeChange.WaitForAttributeChangeWithComparison
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& InAttribute (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& InWithTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& InWithoutTag (Parm, NativeAccessSpecifierPublic)
|
|
// EWaitAttributeChangeComparison InComparisonType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InComparisonValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool TriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitAttributeChange* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitAttributeChange* UAbilityTask_WaitAttributeChange::WaitForAttributeChangeWithComparison(class UObject* WorldContextObject, const struct FGameplayAttribute& InAttribute, const struct FGameplayTag& InWithTag, const struct FGameplayTag& InWithoutTag, EWaitAttributeChangeComparison InComparisonType, float InComparisonValue, bool TriggerOnce)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitAttributeChange", "WaitForAttributeChangeWithComparison");
|
|
|
|
Params::AbilityTask_WaitAttributeChange_WaitForAttributeChangeWithComparison Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InAttribute = std::move(InAttribute);
|
|
Parms.InWithTag = std::move(InWithTag);
|
|
Parms.InWithoutTag = std::move(InWithoutTag);
|
|
Parms.InComparisonType = InComparisonType;
|
|
Parms.InComparisonValue = InComparisonValue;
|
|
Parms.TriggerOnce = TriggerOnce;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_SpawnActor.SpawnActor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (Parm, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class AActor> Class_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_SpawnActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_SpawnActor* UAbilityTask_SpawnActor::SpawnActor(class UObject* WorldContextObject, const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class AActor> Class_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_SpawnActor", "SpawnActor");
|
|
|
|
Params::AbilityTask_SpawnActor_SpawnActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.Class_0 = Class_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_SpawnActor.BeginSpawningActor
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (Parm, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class AActor> Class_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AActor** SpawnedActor (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilityTask_SpawnActor::BeginSpawningActor(class UObject* WorldContextObject, const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class AActor> Class_0, class AActor** SpawnedActor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_SpawnActor", "BeginSpawningActor");
|
|
|
|
Params::AbilityTask_SpawnActor_BeginSpawningActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.Class_0 = Class_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (SpawnedActor != nullptr)
|
|
*SpawnedActor = Parms.SpawnedActor;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_SpawnActor.FinishSpawningActor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* SpawnedActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_SpawnActor::FinishSpawningActor(class UObject* WorldContextObject, const struct FGameplayAbilityTargetDataHandle& TargetData, class AActor* SpawnedActor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_SpawnActor", "FinishSpawningActor");
|
|
|
|
Params::AbilityTask_SpawnActor_FinishSpawningActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.SpawnedActor = SpawnedActor;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.BP_ApplyGameplayEffectSpecToSelf
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FGameplayEffectSpecHandle& SpecHandle (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UAbilitySystemComponent::BP_ApplyGameplayEffectSpecToSelf(struct FGameplayEffectSpecHandle& SpecHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "BP_ApplyGameplayEffectSpecToSelf");
|
|
|
|
Params::AbilitySystemComponent_BP_ApplyGameplayEffectSpecToSelf Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
SpecHandle = std::move(Parms.SpecHandle);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.BP_ApplyGameplayEffectSpecToTarget
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FGameplayEffectSpecHandle& SpecHandle (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// class UAbilitySystemComponent* Target (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UAbilitySystemComponent::BP_ApplyGameplayEffectSpecToTarget(struct FGameplayEffectSpecHandle& SpecHandle, class UAbilitySystemComponent* Target)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "BP_ApplyGameplayEffectSpecToTarget");
|
|
|
|
Params::AbilitySystemComponent_BP_ApplyGameplayEffectSpecToTarget Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.Target = Target;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
SpecHandle = std::move(Parms.SpecHandle);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.BP_ApplyGameplayEffectToSelf
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayEffect> GameplayEffectClass (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UAbilitySystemComponent::BP_ApplyGameplayEffectToSelf(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level, const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "BP_ApplyGameplayEffectToSelf");
|
|
|
|
Params::AbilitySystemComponent_BP_ApplyGameplayEffectToSelf Parms{};
|
|
|
|
Parms.GameplayEffectClass = GameplayEffectClass;
|
|
Parms.Level = Level;
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.BP_ApplyGameplayEffectToTarget
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayEffect> GameplayEffectClass (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilitySystemComponent* Target (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&Context (Parm, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UAbilitySystemComponent::BP_ApplyGameplayEffectToTarget(TSubclassOf<class UGameplayEffect> GameplayEffectClass, class UAbilitySystemComponent* Target, float Level, const struct FGameplayEffectContextHandle& Context)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "BP_ApplyGameplayEffectToTarget");
|
|
|
|
Params::AbilitySystemComponent_BP_ApplyGameplayEffectToTarget Parms{};
|
|
|
|
Parms.GameplayEffectClass = GameplayEffectClass;
|
|
Parms.Target = Target;
|
|
Parms.Level = Level;
|
|
Parms.Context = std::move(Context);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientActivateAbilityFailed
|
|
// (Net, NetReliable, Native, Event, Protected, NetClient)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToActivate (Parm, NativeAccessSpecifierPublic)
|
|
// int16 PredictionKey (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientActivateAbilityFailed(const struct FGameplayAbilitySpecHandle& AbilityToActivate, int16 PredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientActivateAbilityFailed");
|
|
|
|
Params::AbilitySystemComponent_ClientActivateAbilityFailed Parms{};
|
|
|
|
Parms.AbilityToActivate = std::move(AbilityToActivate);
|
|
Parms.PredictionKey = PredictionKey;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientActivateAbilitySucceed
|
|
// (Net, NetReliable, Native, Event, Protected, NetClient)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToActivate (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientActivateAbilitySucceed(const struct FGameplayAbilitySpecHandle& AbilityToActivate, const struct FPredictionKey& PredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientActivateAbilitySucceed");
|
|
|
|
Params::AbilitySystemComponent_ClientActivateAbilitySucceed Parms{};
|
|
|
|
Parms.AbilityToActivate = std::move(AbilityToActivate);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientActivateAbilitySucceedWithEventData
|
|
// (Net, NetReliable, Native, Event, Protected, NetClient)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToActivate (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEventData& TriggerEventData (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientActivateAbilitySucceedWithEventData(const struct FGameplayAbilitySpecHandle& AbilityToActivate, const struct FPredictionKey& PredictionKey, const struct FGameplayEventData& TriggerEventData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientActivateAbilitySucceedWithEventData");
|
|
|
|
Params::AbilitySystemComponent_ClientActivateAbilitySucceedWithEventData Parms{};
|
|
|
|
Parms.AbilityToActivate = std::move(AbilityToActivate);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
Parms.TriggerEventData = std::move(TriggerEventData);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientCancelAbility
|
|
// (Net, NetReliable, Native, Event, Protected, NetClient)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToCancel (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityActivationInfo&ActivationInfo (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientCancelAbility(const struct FGameplayAbilitySpecHandle& AbilityToCancel, const struct FGameplayAbilityActivationInfo& ActivationInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientCancelAbility");
|
|
|
|
Params::AbilitySystemComponent_ClientCancelAbility Parms{};
|
|
|
|
Parms.AbilityToCancel = std::move(AbilityToCancel);
|
|
Parms.ActivationInfo = std::move(ActivationInfo);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientEndAbility
|
|
// (Net, NetReliable, Native, Event, Protected, NetClient)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToEnd (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityActivationInfo&ActivationInfo (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientEndAbility(const struct FGameplayAbilitySpecHandle& AbilityToEnd, const struct FGameplayAbilityActivationInfo& ActivationInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientEndAbility");
|
|
|
|
Params::AbilitySystemComponent_ClientEndAbility Parms{};
|
|
|
|
Parms.AbilityToEnd = std::move(AbilityToEnd);
|
|
Parms.ActivationInfo = std::move(ActivationInfo);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientPrintDebug_Response
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// const TArray<class FString>& Strings (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientPrintDebug_Response(const TArray<class FString>& Strings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientPrintDebug_Response");
|
|
|
|
Params::AbilitySystemComponent_ClientPrintDebug_Response Parms{};
|
|
|
|
Parms.Strings = std::move(Strings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientSetReplicatedEvent
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// EAbilityGenericReplicatedEvent EventType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilitySpecHandle&AbilityHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& AbilityOriginalPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientSetReplicatedEvent(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientSetReplicatedEvent");
|
|
|
|
Params::AbilitySystemComponent_ClientSetReplicatedEvent Parms{};
|
|
|
|
Parms.EventType = EventType;
|
|
Parms.AbilityHandle = std::move(AbilityHandle);
|
|
Parms.AbilityOriginalPredictionKey = std::move(AbilityOriginalPredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ClientTryActivateAbility
|
|
// (Net, NetReliable, Native, Event, Protected, NetClient)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToActivate (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ClientTryActivateAbility(const struct FGameplayAbilitySpecHandle& AbilityToActivate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ClientTryActivateAbility");
|
|
|
|
Params::AbilitySystemComponent_ClientTryActivateAbility Parms{};
|
|
|
|
Parms.AbilityToActivate = std::move(AbilityToActivate);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.GetGameplayEffectCount
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayEffect> SourceGameplayEffect (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilitySystemComponent* OptionalInstigatorFilterComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bEnforceOnGoingCheck (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UAbilitySystemComponent::GetGameplayEffectCount(TSubclassOf<class UGameplayEffect> SourceGameplayEffect, class UAbilitySystemComponent* OptionalInstigatorFilterComponent, bool bEnforceOnGoingCheck)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "GetGameplayEffectCount");
|
|
|
|
Params::AbilitySystemComponent_GetGameplayEffectCount Parms{};
|
|
|
|
Parms.SourceGameplayEffect = SourceGameplayEffect;
|
|
Parms.OptionalInstigatorFilterComponent = OptionalInstigatorFilterComponent;
|
|
Parms.bEnforceOnGoingCheck = bEnforceOnGoingCheck;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.K2_ApplyGameplayEffectToSelf
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class UGameplayEffect* GameplayEffect (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UAbilitySystemComponent::K2_ApplyGameplayEffectToSelf(const class UGameplayEffect* GameplayEffect, float Level, const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "K2_ApplyGameplayEffectToSelf");
|
|
|
|
Params::AbilitySystemComponent_K2_ApplyGameplayEffectToSelf Parms{};
|
|
|
|
Parms.GameplayEffect = GameplayEffect;
|
|
Parms.Level = Level;
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.K2_ApplyGameplayEffectToTarget
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UGameplayEffect* GameplayEffect (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilitySystemComponent* Target (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&Context (Parm, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UAbilitySystemComponent::K2_ApplyGameplayEffectToTarget(class UGameplayEffect* GameplayEffect, class UAbilitySystemComponent* Target, float Level, const struct FGameplayEffectContextHandle& Context)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "K2_ApplyGameplayEffectToTarget");
|
|
|
|
Params::AbilitySystemComponent_K2_ApplyGameplayEffectToTarget Parms{};
|
|
|
|
Parms.GameplayEffect = GameplayEffect;
|
|
Parms.Target = Target;
|
|
Parms.Level = Level;
|
|
Parms.Context = std::move(Context);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.K2_InitStats
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TSubclassOf<class UAttributeSet> Attributes (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const class UDataTable* DataTable (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::K2_InitStats(TSubclassOf<class UAttributeSet> Attributes, const class UDataTable* DataTable)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "K2_InitStats");
|
|
|
|
Params::AbilitySystemComponent_K2_InitStats Parms{};
|
|
|
|
Parms.Attributes = Attributes;
|
|
Parms.DataTable = DataTable;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.NetMulticast_InvokeGameplayCueAdded
|
|
// (Net, Native, Event, NetMulticast, Public)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::NetMulticast_InvokeGameplayCueAdded(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "NetMulticast_InvokeGameplayCueAdded");
|
|
|
|
Params::AbilitySystemComponent_NetMulticast_InvokeGameplayCueAdded Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.NetMulticast_InvokeGameplayCueAddedAndWhileActive_FromSpec
|
|
// (Net, Native, Event, NetMulticast, Public)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecForRPC& Spec (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::NetMulticast_InvokeGameplayCueAddedAndWhileActive_FromSpec(const struct FGameplayEffectSpecForRPC& Spec, const struct FPredictionKey& PredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "NetMulticast_InvokeGameplayCueAddedAndWhileActive_FromSpec");
|
|
|
|
Params::AbilitySystemComponent_NetMulticast_InvokeGameplayCueAddedAndWhileActive_FromSpec Parms{};
|
|
|
|
Parms.Spec = std::move(Spec);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.NetMulticast_InvokeGameplayCueExecuted
|
|
// (Net, Native, Event, NetMulticast, Public)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::NetMulticast_InvokeGameplayCueExecuted(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "NetMulticast_InvokeGameplayCueExecuted");
|
|
|
|
Params::AbilitySystemComponent_NetMulticast_InvokeGameplayCueExecuted Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.NetMulticast_InvokeGameplayCueExecuted_FromSpec
|
|
// (Net, Native, Event, NetMulticast, Public)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecForRPC& Spec (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::NetMulticast_InvokeGameplayCueExecuted_FromSpec(const struct FGameplayEffectSpecForRPC& Spec, const struct FPredictionKey& PredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "NetMulticast_InvokeGameplayCueExecuted_FromSpec");
|
|
|
|
Params::AbilitySystemComponent_NetMulticast_InvokeGameplayCueExecuted_FromSpec Parms{};
|
|
|
|
Parms.Spec = std::move(Spec);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.NetMulticast_InvokeGameplayCueExecuted_WithParams
|
|
// (Net, Native, Event, NetMulticast, Public)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& GameplayCueParameters (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::NetMulticast_InvokeGameplayCueExecuted_WithParams(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "NetMulticast_InvokeGameplayCueExecuted_WithParams");
|
|
|
|
Params::AbilitySystemComponent_NetMulticast_InvokeGameplayCueExecuted_WithParams Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
Parms.GameplayCueParameters = std::move(GameplayCueParameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.OnRep_ActivateAbilities
|
|
// (Final, Native, Protected)
|
|
|
|
void UAbilitySystemComponent::OnRep_ActivateAbilities()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "OnRep_ActivateAbilities");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.OnRep_GameplayEffects
|
|
// (Final, Native, Protected)
|
|
|
|
void UAbilitySystemComponent::OnRep_GameplayEffects()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "OnRep_GameplayEffects");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.OnRep_OwningActor
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilitySystemComponent::OnRep_OwningActor()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "OnRep_OwningActor");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.OnRep_PredictionKey
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilitySystemComponent::OnRep_PredictionKey()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "OnRep_PredictionKey");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.OnRep_ReplicatedAnimMontage
|
|
// (Final, Native, Protected)
|
|
|
|
void UAbilitySystemComponent::OnRep_ReplicatedAnimMontage()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "OnRep_ReplicatedAnimMontage");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.RemoveActiveEffectsWithAppliedTags
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTagContainer& Tags (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::RemoveActiveEffectsWithAppliedTags(const struct FGameplayTagContainer& Tags)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "RemoveActiveEffectsWithAppliedTags");
|
|
|
|
Params::AbilitySystemComponent_RemoveActiveEffectsWithAppliedTags Parms{};
|
|
|
|
Parms.Tags = std::move(Tags);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.RemoveActiveEffectsWithGrantedTags
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTagContainer& Tags (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::RemoveActiveEffectsWithGrantedTags(const struct FGameplayTagContainer& Tags)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "RemoveActiveEffectsWithGrantedTags");
|
|
|
|
Params::AbilitySystemComponent_RemoveActiveEffectsWithGrantedTags Parms{};
|
|
|
|
Parms.Tags = std::move(Tags);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.RemoveActiveEffectsWithSourceTags
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTagContainer& Tags (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::RemoveActiveEffectsWithSourceTags(const struct FGameplayTagContainer& Tags)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "RemoveActiveEffectsWithSourceTags");
|
|
|
|
Params::AbilitySystemComponent_RemoveActiveEffectsWithSourceTags Parms{};
|
|
|
|
Parms.Tags = std::move(Tags);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.RemoveActiveEffectsWithTags
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTagContainer& Tags (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::RemoveActiveEffectsWithTags(const struct FGameplayTagContainer& Tags)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "RemoveActiveEffectsWithTags");
|
|
|
|
Params::AbilitySystemComponent_RemoveActiveEffectsWithTags Parms{};
|
|
|
|
Parms.Tags = std::move(Tags);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.RemoveActiveGameplayEffect
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FActiveGameplayEffectHandle&Handle (Parm, NativeAccessSpecifierPublic)
|
|
// int32 StacksToRemove (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemComponent::RemoveActiveGameplayEffect(const struct FActiveGameplayEffectHandle& Handle, int32 StacksToRemove)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "RemoveActiveGameplayEffect");
|
|
|
|
Params::AbilitySystemComponent_RemoveActiveGameplayEffect Parms{};
|
|
|
|
Parms.Handle = std::move(Handle);
|
|
Parms.StacksToRemove = StacksToRemove;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.RemoveActiveGameplayEffectBySourceEffect
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayEffect> GameplayEffect (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilitySystemComponent* InstigatorAbilitySystemComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 StacksToRemove (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::RemoveActiveGameplayEffectBySourceEffect(TSubclassOf<class UGameplayEffect> GameplayEffect, class UAbilitySystemComponent* InstigatorAbilitySystemComponent, int32 StacksToRemove)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "RemoveActiveGameplayEffectBySourceEffect");
|
|
|
|
Params::AbilitySystemComponent_RemoveActiveGameplayEffectBySourceEffect Parms{};
|
|
|
|
Parms.GameplayEffect = GameplayEffect;
|
|
Parms.InstigatorAbilitySystemComponent = InstigatorAbilitySystemComponent;
|
|
Parms.StacksToRemove = StacksToRemove;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerCancelAbility
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToCancel (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityActivationInfo&ActivationInfo (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerCancelAbility(const struct FGameplayAbilitySpecHandle& AbilityToCancel, const struct FGameplayAbilityActivationInfo& ActivationInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerCancelAbility");
|
|
|
|
Params::AbilitySystemComponent_ServerCancelAbility Parms{};
|
|
|
|
Parms.AbilityToCancel = std::move(AbilityToCancel);
|
|
Parms.ActivationInfo = std::move(ActivationInfo);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerCurrentMontageJumpToSectionName
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// class UAnimMontage* ClientAnimMontage (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName SectionName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerCurrentMontageJumpToSectionName(class UAnimMontage* ClientAnimMontage, class FName SectionName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerCurrentMontageJumpToSectionName");
|
|
|
|
Params::AbilitySystemComponent_ServerCurrentMontageJumpToSectionName Parms{};
|
|
|
|
Parms.ClientAnimMontage = ClientAnimMontage;
|
|
Parms.SectionName = SectionName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerCurrentMontageSetNextSectionName
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// class UAnimMontage* ClientAnimMontage (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ClientPosition (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName SectionName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName NextSectionName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerCurrentMontageSetNextSectionName(class UAnimMontage* ClientAnimMontage, float ClientPosition, class FName SectionName, class FName NextSectionName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerCurrentMontageSetNextSectionName");
|
|
|
|
Params::AbilitySystemComponent_ServerCurrentMontageSetNextSectionName Parms{};
|
|
|
|
Parms.ClientAnimMontage = ClientAnimMontage;
|
|
Parms.ClientPosition = ClientPosition;
|
|
Parms.SectionName = SectionName;
|
|
Parms.NextSectionName = NextSectionName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerCurrentMontageSetPlayRate
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// class UAnimMontage* ClientAnimMontage (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerCurrentMontageSetPlayRate(class UAnimMontage* ClientAnimMontage, float InPlayRate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerCurrentMontageSetPlayRate");
|
|
|
|
Params::AbilitySystemComponent_ServerCurrentMontageSetPlayRate Parms{};
|
|
|
|
Parms.ClientAnimMontage = ClientAnimMontage;
|
|
Parms.InPlayRate = InPlayRate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerEndAbility
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToEnd (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityActivationInfo&ActivationInfo (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerEndAbility(const struct FGameplayAbilitySpecHandle& AbilityToEnd, const struct FGameplayAbilityActivationInfo& ActivationInfo, const struct FPredictionKey& PredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerEndAbility");
|
|
|
|
Params::AbilitySystemComponent_ServerEndAbility Parms{};
|
|
|
|
Parms.AbilityToEnd = std::move(AbilityToEnd);
|
|
Parms.ActivationInfo = std::move(ActivationInfo);
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerPrintDebug_Request
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void UAbilitySystemComponent::ServerPrintDebug_Request()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerPrintDebug_Request");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerSetInputPressed
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityHandle (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerSetInputPressed(const struct FGameplayAbilitySpecHandle& AbilityHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerSetInputPressed");
|
|
|
|
Params::AbilitySystemComponent_ServerSetInputPressed Parms{};
|
|
|
|
Parms.AbilityHandle = std::move(AbilityHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerSetInputReleased
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityHandle (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerSetInputReleased(const struct FGameplayAbilitySpecHandle& AbilityHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerSetInputReleased");
|
|
|
|
Params::AbilitySystemComponent_ServerSetInputReleased Parms{};
|
|
|
|
Parms.AbilityHandle = std::move(AbilityHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerSetReplicatedEvent
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// EAbilityGenericReplicatedEvent EventType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilitySpecHandle&AbilityHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& AbilityOriginalPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& CurrentPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerSetReplicatedEvent(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerSetReplicatedEvent");
|
|
|
|
Params::AbilitySystemComponent_ServerSetReplicatedEvent Parms{};
|
|
|
|
Parms.EventType = EventType;
|
|
Parms.AbilityHandle = std::move(AbilityHandle);
|
|
Parms.AbilityOriginalPredictionKey = std::move(AbilityOriginalPredictionKey);
|
|
Parms.CurrentPredictionKey = std::move(CurrentPredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerSetReplicatedEventWithPayload
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// EAbilityGenericReplicatedEvent EventType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilitySpecHandle&AbilityHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& AbilityOriginalPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& CurrentPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FVector_NetQuantize100& VectorPayload (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerSetReplicatedEventWithPayload(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey, const struct FVector_NetQuantize100& VectorPayload)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerSetReplicatedEventWithPayload");
|
|
|
|
Params::AbilitySystemComponent_ServerSetReplicatedEventWithPayload Parms{};
|
|
|
|
Parms.EventType = EventType;
|
|
Parms.AbilityHandle = std::move(AbilityHandle);
|
|
Parms.AbilityOriginalPredictionKey = std::move(AbilityOriginalPredictionKey);
|
|
Parms.CurrentPredictionKey = std::move(CurrentPredictionKey);
|
|
Parms.VectorPayload = std::move(VectorPayload);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerSetReplicatedTargetData
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& AbilityOriginalPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityTargetDataHandle&ReplicatedTargetDataHandle (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& ApplicationTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& CurrentPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerSetReplicatedTargetData(const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FGameplayAbilityTargetDataHandle& ReplicatedTargetDataHandle, const struct FGameplayTag& ApplicationTag, const struct FPredictionKey& CurrentPredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerSetReplicatedTargetData");
|
|
|
|
Params::AbilitySystemComponent_ServerSetReplicatedTargetData Parms{};
|
|
|
|
Parms.AbilityHandle = std::move(AbilityHandle);
|
|
Parms.AbilityOriginalPredictionKey = std::move(AbilityOriginalPredictionKey);
|
|
Parms.ReplicatedTargetDataHandle = std::move(ReplicatedTargetDataHandle);
|
|
Parms.ApplicationTag = std::move(ApplicationTag);
|
|
Parms.CurrentPredictionKey = std::move(CurrentPredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerSetReplicatedTargetDataCancelled
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& AbilityOriginalPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& CurrentPredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerSetReplicatedTargetDataCancelled(const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerSetReplicatedTargetDataCancelled");
|
|
|
|
Params::AbilitySystemComponent_ServerSetReplicatedTargetDataCancelled Parms{};
|
|
|
|
Parms.AbilityHandle = std::move(AbilityHandle);
|
|
Parms.AbilityOriginalPredictionKey = std::move(AbilityOriginalPredictionKey);
|
|
Parms.CurrentPredictionKey = std::move(CurrentPredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerTryActivateAbility
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToActivate (Parm, NativeAccessSpecifierPublic)
|
|
// bool InputPressed (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerTryActivateAbility(const struct FGameplayAbilitySpecHandle& AbilityToActivate, bool InputPressed, const struct FPredictionKey& PredictionKey)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerTryActivateAbility");
|
|
|
|
Params::AbilitySystemComponent_ServerTryActivateAbility Parms{};
|
|
|
|
Parms.AbilityToActivate = std::move(AbilityToActivate);
|
|
Parms.InputPressed = InputPressed;
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.ServerTryActivateAbilityWithEventData
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// const struct FGameplayAbilitySpecHandle&AbilityToActivate (Parm, NativeAccessSpecifierPublic)
|
|
// bool InputPressed (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// const struct FPredictionKey& PredictionKey (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEventData& TriggerEventData (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::ServerTryActivateAbilityWithEventData(const struct FGameplayAbilitySpecHandle& AbilityToActivate, bool InputPressed, const struct FPredictionKey& PredictionKey, const struct FGameplayEventData& TriggerEventData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "ServerTryActivateAbilityWithEventData");
|
|
|
|
Params::AbilitySystemComponent_ServerTryActivateAbilityWithEventData Parms{};
|
|
|
|
Parms.AbilityToActivate = std::move(AbilityToActivate);
|
|
Parms.InputPressed = InputPressed;
|
|
Parms.PredictionKey = std::move(PredictionKey);
|
|
Parms.TriggerEventData = std::move(TriggerEventData);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.SetActiveGameplayEffectLevel
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FActiveGameplayEffectHandle&ActiveHandle (Parm, NativeAccessSpecifierPublic)
|
|
// int32 NewLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::SetActiveGameplayEffectLevel(const struct FActiveGameplayEffectHandle& ActiveHandle, int32 NewLevel)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "SetActiveGameplayEffectLevel");
|
|
|
|
Params::AbilitySystemComponent_SetActiveGameplayEffectLevel Parms{};
|
|
|
|
Parms.ActiveHandle = std::move(ActiveHandle);
|
|
Parms.NewLevel = NewLevel;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.SetUserAbilityActivationInhibited
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewInhibit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemComponent::SetUserAbilityActivationInhibited(bool NewInhibit)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "SetUserAbilityActivationInhibited");
|
|
|
|
Params::AbilitySystemComponent_SetUserAbilityActivationInhibited Parms{};
|
|
|
|
Parms.NewInhibit = NewInhibit;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.TargetCancel
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAbilitySystemComponent::TargetCancel()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "TargetCancel");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.TargetConfirm
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAbilitySystemComponent::TargetConfirm()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "TargetConfirm");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.TryActivateAbilitiesByTag
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTagContainer& GameplayTagContainer (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool bAllowRemoteActivation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemComponent::TryActivateAbilitiesByTag(const struct FGameplayTagContainer& GameplayTagContainer, bool bAllowRemoteActivation)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "TryActivateAbilitiesByTag");
|
|
|
|
Params::AbilitySystemComponent_TryActivateAbilitiesByTag Parms{};
|
|
|
|
Parms.GameplayTagContainer = std::move(GameplayTagContainer);
|
|
Parms.bAllowRemoteActivation = bAllowRemoteActivation;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.TryActivateAbilityByClass
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayAbility> InAbilityToActivate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bAllowRemoteActivation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemComponent::TryActivateAbilityByClass(TSubclassOf<class UGameplayAbility> InAbilityToActivate, bool bAllowRemoteActivation)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "TryActivateAbilityByClass");
|
|
|
|
Params::AbilitySystemComponent_TryActivateAbilityByClass Parms{};
|
|
|
|
Parms.InAbilityToActivate = InAbilityToActivate;
|
|
Parms.bAllowRemoteActivation = bAllowRemoteActivation;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.GetGameplayEffectMagnitude
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// const struct FActiveGameplayEffectHandle&Handle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& Attribute (Parm, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAbilitySystemComponent::GetGameplayEffectMagnitude(const struct FActiveGameplayEffectHandle& Handle, const struct FGameplayAttribute& Attribute) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "GetGameplayEffectMagnitude");
|
|
|
|
Params::AbilitySystemComponent_GetGameplayEffectMagnitude Parms{};
|
|
|
|
Parms.Handle = std::move(Handle);
|
|
Parms.Attribute = std::move(Attribute);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.GetOutgoingSpec
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// const class UGameplayEffect* GameplayEffect (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemComponent::GetOutgoingSpec(const class UGameplayEffect* GameplayEffect, float Level) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "GetOutgoingSpec");
|
|
|
|
Params::AbilitySystemComponent_GetOutgoingSpec Parms{};
|
|
|
|
Parms.GameplayEffect = GameplayEffect;
|
|
Parms.Level = Level;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.GetUserAbilityActivationInhibited
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemComponent::GetUserAbilityActivationInhibited() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "GetUserAbilityActivationInhibited");
|
|
|
|
Params::AbilitySystemComponent_GetUserAbilityActivationInhibited Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.IsGameplayCueActive
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemComponent::IsGameplayCueActive(const struct FGameplayTag& GameplayCueTag) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "IsGameplayCueActive");
|
|
|
|
Params::AbilitySystemComponent_IsGameplayCueActive Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.MakeEffectContext
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FGameplayEffectContextHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectContextHandle UAbilitySystemComponent::MakeEffectContext() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "MakeEffectContext");
|
|
|
|
Params::AbilitySystemComponent_MakeEffectContext Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemComponent.MakeOutgoingSpec
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayEffect> GameplayEffectClass (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&Context (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemComponent::MakeOutgoingSpec(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level, const struct FGameplayEffectContextHandle& Context) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemComponent", "MakeOutgoingSpec");
|
|
|
|
Params::AbilitySystemComponent_MakeOutgoingSpec Parms{};
|
|
|
|
Parms.GameplayEffectClass = GameplayEffectClass;
|
|
Parms.Level = Level;
|
|
Parms.Context = std::move(Context);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityTargetActor.CancelTargeting
|
|
// (Native, Public)
|
|
|
|
void AGameplayAbilityTargetActor::CancelTargeting()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityTargetActor", "CancelTargeting");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityTargetActor.ConfirmTargeting
|
|
// (Native, Public)
|
|
|
|
void AGameplayAbilityTargetActor::ConfirmTargeting()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityTargetActor", "ConfirmTargeting");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEffectApplied.OnApplyGameplayEffectCallback
|
|
// (Final, Native, Public, HasOutParams)
|
|
// Parameters:
|
|
// class UAbilitySystemComponent* Target (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectSpec& SpecApplied (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const struct FActiveGameplayEffectHandle&ActiveHandle (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitGameplayEffectApplied::OnApplyGameplayEffectCallback(class UAbilitySystemComponent* Target, const struct FGameplayEffectSpec& SpecApplied, const struct FActiveGameplayEffectHandle& ActiveHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitGameplayEffectApplied", "OnApplyGameplayEffectCallback");
|
|
|
|
Params::AbilityTask_WaitGameplayEffectApplied_OnApplyGameplayEffectCallback Parms{};
|
|
|
|
Parms.Target = Target;
|
|
Parms.SpecApplied = std::move(SpecApplied);
|
|
Parms.ActiveHandle = std::move(ActiveHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemGlobals.ToggleIgnoreAbilitySystemCooldowns
|
|
// (Exec, Native, Public)
|
|
|
|
void UAbilitySystemGlobals::ToggleIgnoreAbilitySystemCooldowns()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemGlobals", "ToggleIgnoreAbilitySystemCooldowns");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemGlobals.ToggleIgnoreAbilitySystemCosts
|
|
// (Exec, Native, Public)
|
|
|
|
void UAbilitySystemGlobals::ToggleIgnoreAbilitySystemCosts()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilitySystemGlobals", "ToggleIgnoreAbilitySystemCosts");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.BP_ApplyGameplayEffectToOwner
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayEffect> GameplayEffectClass (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 GameplayEffectLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 Stacks (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UGameplayAbility::BP_ApplyGameplayEffectToOwner(TSubclassOf<class UGameplayEffect> GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "BP_ApplyGameplayEffectToOwner");
|
|
|
|
Params::GameplayAbility_BP_ApplyGameplayEffectToOwner Parms{};
|
|
|
|
Parms.GameplayEffectClass = GameplayEffectClass;
|
|
Parms.GameplayEffectLevel = GameplayEffectLevel;
|
|
Parms.Stacks = Stacks;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.BP_ApplyGameplayEffectToTarget
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (Parm, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class UGameplayEffect> GameplayEffectClass (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 GameplayEffectLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 Stacks (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FActiveGameplayEffectHandle>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FActiveGameplayEffectHandle> UGameplayAbility::BP_ApplyGameplayEffectToTarget(const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class UGameplayEffect> GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "BP_ApplyGameplayEffectToTarget");
|
|
|
|
Params::GameplayAbility_BP_ApplyGameplayEffectToTarget Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.GameplayEffectClass = GameplayEffectClass;
|
|
Parms.GameplayEffectLevel = GameplayEffectLevel;
|
|
Parms.Stacks = Stacks;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.BP_RemoveGameplayEffectFromOwnerWithAssetTags
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTagContainer& WithAssetTags (Parm, NativeAccessSpecifierPublic)
|
|
// int32 StacksToRemove (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::BP_RemoveGameplayEffectFromOwnerWithAssetTags(const struct FGameplayTagContainer& WithAssetTags, int32 StacksToRemove)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "BP_RemoveGameplayEffectFromOwnerWithAssetTags");
|
|
|
|
Params::GameplayAbility_BP_RemoveGameplayEffectFromOwnerWithAssetTags Parms{};
|
|
|
|
Parms.WithAssetTags = std::move(WithAssetTags);
|
|
Parms.StacksToRemove = StacksToRemove;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.BP_RemoveGameplayEffectFromOwnerWithGrantedTags
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTagContainer& WithGrantedTags (Parm, NativeAccessSpecifierPublic)
|
|
// int32 StacksToRemove (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::BP_RemoveGameplayEffectFromOwnerWithGrantedTags(const struct FGameplayTagContainer& WithGrantedTags, int32 StacksToRemove)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "BP_RemoveGameplayEffectFromOwnerWithGrantedTags");
|
|
|
|
Params::GameplayAbility_BP_RemoveGameplayEffectFromOwnerWithGrantedTags Parms{};
|
|
|
|
Parms.WithGrantedTags = std::move(WithGrantedTags);
|
|
Parms.StacksToRemove = StacksToRemove;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.CancelTaskByInstanceName
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// class FName InstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::CancelTaskByInstanceName(class FName InstanceName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "CancelTaskByInstanceName");
|
|
|
|
Params::GameplayAbility_CancelTaskByInstanceName Parms{};
|
|
|
|
Parms.InstanceName = InstanceName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.ConfirmTaskByInstanceName
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// class FName InstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bEndTask (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::ConfirmTaskByInstanceName(class FName InstanceName, bool bEndTask)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "ConfirmTaskByInstanceName");
|
|
|
|
Params::GameplayAbility_ConfirmTaskByInstanceName Parms{};
|
|
|
|
Parms.InstanceName = InstanceName;
|
|
Parms.bEndTask = bEndTask;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.EndAbilityState
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// class FName OptionalStateNameToEnd (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::EndAbilityState(class FName OptionalStateNameToEnd)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "EndAbilityState");
|
|
|
|
Params::GameplayAbility_EndAbilityState Parms{};
|
|
|
|
Parms.OptionalStateNameToEnd = OptionalStateNameToEnd;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.EndTaskByInstanceName
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// class FName InstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::EndTaskByInstanceName(class FName InstanceName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "EndTaskByInstanceName");
|
|
|
|
Params::GameplayAbility_EndTaskByInstanceName Parms{};
|
|
|
|
Parms.InstanceName = InstanceName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ActivateAbility
|
|
// (Event, Protected, BlueprintEvent)
|
|
|
|
void UGameplayAbility::K2_ActivateAbility()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ActivateAbility");
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ActivateAbilityFromEvent
|
|
// (Event, Protected, HasOutParams, BlueprintEvent)
|
|
// Parameters:
|
|
// const struct FGameplayEventData& EventData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::K2_ActivateAbilityFromEvent(const struct FGameplayEventData& EventData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ActivateAbilityFromEvent");
|
|
|
|
Params::GameplayAbility_K2_ActivateAbilityFromEvent Parms{};
|
|
|
|
Parms.EventData = std::move(EventData);
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_AddGameplayCue
|
|
// (Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&Context (Parm, NativeAccessSpecifierPublic)
|
|
// bool bRemoveOnAbilityEnd (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::K2_AddGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context, bool bRemoveOnAbilityEnd)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_AddGameplayCue");
|
|
|
|
Params::GameplayAbility_K2_AddGameplayCue Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
Parms.Context = std::move(Context);
|
|
Parms.bRemoveOnAbilityEnd = bRemoveOnAbilityEnd;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ApplyGameplayEffectSpecToOwner
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& EffectSpecHandle (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UGameplayAbility::K2_ApplyGameplayEffectSpecToOwner(const struct FGameplayEffectSpecHandle& EffectSpecHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ApplyGameplayEffectSpecToOwner");
|
|
|
|
Params::GameplayAbility_K2_ApplyGameplayEffectSpecToOwner Parms{};
|
|
|
|
Parms.EffectSpecHandle = std::move(EffectSpecHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ApplyGameplayEffectSpecToTarget
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& EffectSpecHandle (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (Parm, NativeAccessSpecifierPublic)
|
|
// TArray<struct FActiveGameplayEffectHandle>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FActiveGameplayEffectHandle> UGameplayAbility::K2_ApplyGameplayEffectSpecToTarget(const struct FGameplayEffectSpecHandle& EffectSpecHandle, const struct FGameplayAbilityTargetDataHandle& TargetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ApplyGameplayEffectSpecToTarget");
|
|
|
|
Params::GameplayAbility_K2_ApplyGameplayEffectSpecToTarget Parms{};
|
|
|
|
Parms.EffectSpecHandle = std::move(EffectSpecHandle);
|
|
Parms.TargetData = std::move(TargetData);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ApplyGameplayEffectToOwner
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const class UGameplayEffect* GameplayEffect (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 GameplayEffectLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 Stacks (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FActiveGameplayEffectHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FActiveGameplayEffectHandle UGameplayAbility::K2_ApplyGameplayEffectToOwner(const class UGameplayEffect* GameplayEffect, int32 GameplayEffectLevel, int32 Stacks)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ApplyGameplayEffectToOwner");
|
|
|
|
Params::GameplayAbility_K2_ApplyGameplayEffectToOwner Parms{};
|
|
|
|
Parms.GameplayEffect = GameplayEffect;
|
|
Parms.GameplayEffectLevel = GameplayEffectLevel;
|
|
Parms.Stacks = Stacks;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ApplyGameplayEffectToTarget
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (Parm, NativeAccessSpecifierPublic)
|
|
// const class UGameplayEffect* GameplayEffect (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 GameplayEffectLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 Stacks (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FActiveGameplayEffectHandle>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FActiveGameplayEffectHandle> UGameplayAbility::K2_ApplyGameplayEffectToTarget(const struct FGameplayAbilityTargetDataHandle& TargetData, const class UGameplayEffect* GameplayEffect, int32 GameplayEffectLevel, int32 Stacks)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ApplyGameplayEffectToTarget");
|
|
|
|
Params::GameplayAbility_K2_ApplyGameplayEffectToTarget Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.GameplayEffect = GameplayEffect;
|
|
Parms.GameplayEffectLevel = GameplayEffectLevel;
|
|
Parms.Stacks = Stacks;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_CheckAbilityCooldown
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayAbility::K2_CheckAbilityCooldown()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_CheckAbilityCooldown");
|
|
|
|
Params::GameplayAbility_K2_CheckAbilityCooldown Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_CheckAbilityCost
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayAbility::K2_CheckAbilityCost()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_CheckAbilityCost");
|
|
|
|
Params::GameplayAbility_K2_CheckAbilityCost Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_CommitAbility
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayAbility::K2_CommitAbility()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_CommitAbility");
|
|
|
|
Params::GameplayAbility_K2_CommitAbility Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_CommitAbilityCooldown
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool BroadcastCommitEvent (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ForceCooldown (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayAbility::K2_CommitAbilityCooldown(bool BroadcastCommitEvent, bool ForceCooldown)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_CommitAbilityCooldown");
|
|
|
|
Params::GameplayAbility_K2_CommitAbilityCooldown Parms{};
|
|
|
|
Parms.BroadcastCommitEvent = BroadcastCommitEvent;
|
|
Parms.ForceCooldown = ForceCooldown;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_CommitAbilityCost
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool BroadcastCommitEvent (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayAbility::K2_CommitAbilityCost(bool BroadcastCommitEvent)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_CommitAbilityCost");
|
|
|
|
Params::GameplayAbility_K2_CommitAbilityCost Parms{};
|
|
|
|
Parms.BroadcastCommitEvent = BroadcastCommitEvent;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_CommitExecute
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UGameplayAbility::K2_CommitExecute()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_CommitExecute");
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_EndAbility
|
|
// (Native, Protected, BlueprintCallable)
|
|
|
|
void UGameplayAbility::K2_EndAbility()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_EndAbility");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ExecuteGameplayCue
|
|
// (Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectContextHandle&Context (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::K2_ExecuteGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ExecuteGameplayCue");
|
|
|
|
Params::GameplayAbility_K2_ExecuteGameplayCue Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
Parms.Context = std::move(Context);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ExecuteGameplayCueWithParams
|
|
// (Native, Protected, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& GameplayCueParameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::K2_ExecuteGameplayCueWithParams(const struct FGameplayTag& GameplayCueTag, const struct FGameplayCueParameters& GameplayCueParameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ExecuteGameplayCueWithParams");
|
|
|
|
Params::GameplayAbility_K2_ExecuteGameplayCueWithParams Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
Parms.GameplayCueParameters = std::move(GameplayCueParameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_OnEndAbility
|
|
// (Event, Protected, BlueprintEvent)
|
|
|
|
void UGameplayAbility::K2_OnEndAbility()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_OnEndAbility");
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_RemoveGameplayCue
|
|
// (Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTag& GameplayCueTag (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::K2_RemoveGameplayCue(const struct FGameplayTag& GameplayCueTag)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_RemoveGameplayCue");
|
|
|
|
Params::GameplayAbility_K2_RemoveGameplayCue Parms{};
|
|
|
|
Parms.GameplayCueTag = std::move(GameplayCueTag);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.MakeTargetLocationInfoFromOwnerActor
|
|
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGameplayAbilityTargetingLocationInfoReturnValue (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetingLocationInfo UGameplayAbility::MakeTargetLocationInfoFromOwnerActor()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "MakeTargetLocationInfoFromOwnerActor");
|
|
|
|
Params::GameplayAbility_MakeTargetLocationInfoFromOwnerActor Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.MakeTargetLocationInfoFromOwnerSkeletalMeshComponent
|
|
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class FName SocketName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayAbilityTargetingLocationInfoReturnValue (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetingLocationInfo UGameplayAbility::MakeTargetLocationInfoFromOwnerSkeletalMeshComponent(class FName SocketName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "MakeTargetLocationInfoFromOwnerSkeletalMeshComponent");
|
|
|
|
Params::GameplayAbility_MakeTargetLocationInfoFromOwnerSkeletalMeshComponent Parms{};
|
|
|
|
Parms.SocketName = SocketName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.MontageJumpToSection
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// class FName SectionName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::MontageJumpToSection(class FName SectionName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "MontageJumpToSection");
|
|
|
|
Params::GameplayAbility_MontageJumpToSection Parms{};
|
|
|
|
Parms.SectionName = SectionName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.MontageSetNextSectionName
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// class FName FromSectionName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ToSectionName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::MontageSetNextSectionName(class FName FromSectionName, class FName ToSectionName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "MontageSetNextSectionName");
|
|
|
|
Params::GameplayAbility_MontageSetNextSectionName Parms{};
|
|
|
|
Parms.FromSectionName = FromSectionName;
|
|
Parms.ToSectionName = ToSectionName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.MontageStop
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// float OverrideBlendOutTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::MontageStop(float OverrideBlendOutTime)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "MontageStop");
|
|
|
|
Params::GameplayAbility_MontageStop Parms{};
|
|
|
|
Parms.OverrideBlendOutTime = OverrideBlendOutTime;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.RemoveGrantedByEffect
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UGameplayAbility::RemoveGrantedByEffect()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "RemoveGrantedByEffect");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.SendGameplayEvent
|
|
// (Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayTag& EventTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEventData& Payload (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::SendGameplayEvent(const struct FGameplayTag& EventTag, const struct FGameplayEventData& Payload)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "SendGameplayEvent");
|
|
|
|
Params::GameplayAbility_SendGameplayEvent Parms{};
|
|
|
|
Parms.EventTag = std::move(EventTag);
|
|
Parms.Payload = std::move(Payload);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.SetCanBeCanceled
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bCanBeCanceled (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::SetCanBeCanceled(bool bCanBeCanceled)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "SetCanBeCanceled");
|
|
|
|
Params::GameplayAbility_SetCanBeCanceled Parms{};
|
|
|
|
Parms.bCanBeCanceled = bCanBeCanceled;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.SetShouldBlockOtherAbilities
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bShouldBlockAbilities (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayAbility::SetShouldBlockOtherAbilities(bool bShouldBlockAbilities)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "SetShouldBlockOtherAbilities");
|
|
|
|
Params::GameplayAbility_SetShouldBlockOtherAbilities Parms{};
|
|
|
|
Parms.bShouldBlockAbilities = bShouldBlockAbilities;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetAbilityLevel
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UGameplayAbility::GetAbilityLevel() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetAbilityLevel");
|
|
|
|
Params::GameplayAbility_GetAbilityLevel Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetActorInfo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FGameplayAbilityActorInfo ReturnValue (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityActorInfo UGameplayAbility::GetActorInfo() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetActorInfo");
|
|
|
|
Params::GameplayAbility_GetActorInfo Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetAvatarActorFromActorInfo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class AActor* UGameplayAbility::GetAvatarActorFromActorInfo() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetAvatarActorFromActorInfo");
|
|
|
|
Params::GameplayAbility_GetAvatarActorFromActorInfo Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetContextFromOwner
|
|
// (Native, Protected, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&OptionalTargetData (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectContextHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectContextHandle UGameplayAbility::GetContextFromOwner(const struct FGameplayAbilityTargetDataHandle& OptionalTargetData) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetContextFromOwner");
|
|
|
|
Params::GameplayAbility_GetContextFromOwner Parms{};
|
|
|
|
Parms.OptionalTargetData = std::move(OptionalTargetData);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetCoolDownTimeRemaining
|
|
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UGameplayAbility::GetCoolDownTimeRemaining() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetCoolDownTimeRemaining");
|
|
|
|
Params::GameplayAbility_GetCoolDownTimeRemaining Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetCurrentMontage
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAnimMontage* UGameplayAbility::GetCurrentMontage() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetCurrentMontage");
|
|
|
|
Params::GameplayAbility_GetCurrentMontage Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetCurrentSourceObject
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UObject* UGameplayAbility::GetCurrentSourceObject() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetCurrentSourceObject");
|
|
|
|
Params::GameplayAbility_GetCurrentSourceObject Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetGrantedByEffectContext
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FGameplayEffectContextHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectContextHandle UGameplayAbility::GetGrantedByEffectContext() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetGrantedByEffectContext");
|
|
|
|
Params::GameplayAbility_GetGrantedByEffectContext Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetOutgoingGameplayEffectSpec
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// const class UGameplayEffect* GameplayEffect (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UGameplayAbility::GetOutgoingGameplayEffectSpec(const class UGameplayEffect* GameplayEffect, float Level) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetOutgoingGameplayEffectSpec");
|
|
|
|
Params::GameplayAbility_GetOutgoingGameplayEffectSpec Parms{};
|
|
|
|
Parms.GameplayEffect = GameplayEffect;
|
|
Parms.Level = Level;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetOwningActorFromActorInfo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class AActor* UGameplayAbility::GetOwningActorFromActorInfo() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetOwningActorFromActorInfo");
|
|
|
|
Params::GameplayAbility_GetOwningActorFromActorInfo Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.GetOwningComponentFromActorInfo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class USkeletalMeshComponent* UGameplayAbility::GetOwningComponentFromActorInfo() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "GetOwningComponentFromActorInfo");
|
|
|
|
Params::GameplayAbility_GetOwningComponentFromActorInfo Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_CanActivateAbility
|
|
// (Event, Protected, HasOutParams, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityActorInfo& ActorInfo (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
// struct FGameplayTagContainer* RelevantTags (Parm, OutParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayAbility::K2_CanActivateAbility(const struct FGameplayAbilityActorInfo& ActorInfo, struct FGameplayTagContainer* RelevantTags) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_CanActivateAbility");
|
|
|
|
Params::GameplayAbility_K2_CanActivateAbility Parms{};
|
|
|
|
Parms.ActorInfo = std::move(ActorInfo);
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
if (RelevantTags != nullptr)
|
|
*RelevantTags = std::move(Parms.RelevantTags);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.K2_ShouldAbilityRespondToEvent
|
|
// (Event, Protected, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityActorInfo& ActorInfo (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEventData& Payload (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UGameplayAbility::K2_ShouldAbilityRespondToEvent(const struct FGameplayAbilityActorInfo& ActorInfo, const struct FGameplayEventData& Payload) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "K2_ShouldAbilityRespondToEvent");
|
|
|
|
Params::GameplayAbility_K2_ShouldAbilityRespondToEvent Parms{};
|
|
|
|
Parms.ActorInfo = std::move(ActorInfo);
|
|
Parms.Payload = std::move(Payload);
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbility.MakeOutgoingGameplayEffectSpec
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TSubclassOf<class UGameplayEffect> GameplayEffectClass (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Level (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UGameplayAbility::MakeOutgoingGameplayEffectSpec(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbility", "MakeOutgoingGameplayEffectSpec");
|
|
|
|
Params::GameplayAbility_MakeOutgoingGameplayEffectSpec Parms{};
|
|
|
|
Parms.GameplayEffectClass = GameplayEffectClass;
|
|
Parms.Level = Level;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitOverlap.WaitForOverlap
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitOverlap* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitOverlap* UAbilityTask_WaitOverlap::WaitForOverlap(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitOverlap", "WaitForOverlap");
|
|
|
|
Params::AbilityTask_WaitOverlap_WaitForOverlap Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitOverlap.OnHitCallback
|
|
// (Final, Native, Public, HasOutParams, HasDefaults)
|
|
// Parameters:
|
|
// class AActor* OtherActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UPrimitiveComponent* OtherComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector& NormalImpulse (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// const struct FHitResult& Hit (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitOverlap::OnHitCallback(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitOverlap", "OnHitCallback");
|
|
|
|
Params::AbilityTask_WaitOverlap_OnHitCallback Parms{};
|
|
|
|
Parms.OtherActor = OtherActor;
|
|
Parms.OtherComp = OtherComp;
|
|
Parms.NormalImpulse = std::move(NormalImpulse);
|
|
Parms.Hit = std::move(Hit);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitOverlap.OnOverlapCallback
|
|
// (Final, Native, Public, HasOutParams)
|
|
// Parameters:
|
|
// class AActor* OtherActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UPrimitiveComponent* OtherComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 OtherBodyIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bFromSweep (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// const struct FHitResult& SweepResult (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitOverlap::OnOverlapCallback(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitOverlap", "OnOverlapCallback");
|
|
|
|
Params::AbilityTask_WaitOverlap_OnOverlapCallback Parms{};
|
|
|
|
Parms.OtherActor = OtherActor;
|
|
Parms.OtherComp = OtherComp;
|
|
Parms.OtherBodyIndex = OtherBodyIndex;
|
|
Parms.bFromSweep = bFromSweep;
|
|
Parms.SweepResult = std::move(SweepResult);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitInputPress.WaitInputPress
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bTestAlreadyPressed (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitInputPress* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitInputPress* UAbilityTask_WaitInputPress::WaitInputPress(class UObject* WorldContextObject, bool bTestAlreadyPressed)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitInputPress", "WaitInputPress");
|
|
|
|
Params::AbilityTask_WaitInputPress_WaitInputPress Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.bTestAlreadyPressed = bTestAlreadyPressed;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitInputPress.OnPressCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitInputPress::OnPressCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitInputPress", "OnPressCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Actor.K2_HandleGameplayCue
|
|
// (Event, Public, HasOutParams, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EGameplayCueEvent EventType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void AGameplayCueNotify_Actor::K2_HandleGameplayCue(class AActor* MyTarget, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Actor", "K2_HandleGameplayCue");
|
|
|
|
Params::GameplayCueNotify_Actor_K2_HandleGameplayCue Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.EventType = EventType;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Actor.OnActive
|
|
// (Native, Event, Public, HasOutParams, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool AGameplayCueNotify_Actor::OnActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Actor", "OnActive");
|
|
|
|
Params::GameplayCueNotify_Actor_OnActive Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Actor.OnExecute
|
|
// (Native, Event, Public, HasOutParams, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool AGameplayCueNotify_Actor::OnExecute(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Actor", "OnExecute");
|
|
|
|
Params::GameplayCueNotify_Actor_OnExecute Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Actor.OnOwnerDestroyed
|
|
// (Native, Public)
|
|
|
|
void AGameplayCueNotify_Actor::OnOwnerDestroyed()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Actor", "OnOwnerDestroyed");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Actor.OnRemove
|
|
// (Native, Event, Public, HasOutParams, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool AGameplayCueNotify_Actor::OnRemove(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Actor", "OnRemove");
|
|
|
|
Params::GameplayCueNotify_Actor_OnRemove Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueNotify_Actor.WhileActive
|
|
// (Native, Event, Public, HasOutParams, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* MyTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool AGameplayCueNotify_Actor::WhileActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueNotify_Actor", "WhileActive");
|
|
|
|
Params::GameplayCueNotify_Actor_WhileActive Parms{};
|
|
|
|
Parms.MyTarget = MyTarget;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_ApplyRootMotionMoveToForce.ApplyRootMotionMoveToForce
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector& TargetLocation_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Duration_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bSetNewMovementMode_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// EMovementMode MovementMode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bRestrictSpeedToExpected_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UCurveVector* PathOffsetCurve_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_ApplyRootMotionMoveToForce*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_ApplyRootMotionMoveToForce* UAbilityTask_ApplyRootMotionMoveToForce::ApplyRootMotionMoveToForce(class UObject* WorldContextObject, class FName TaskInstanceName, const struct FVector& TargetLocation_0, float Duration_0, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveVector* PathOffsetCurve_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_ApplyRootMotionMoveToForce", "ApplyRootMotionMoveToForce");
|
|
|
|
Params::AbilityTask_ApplyRootMotionMoveToForce_ApplyRootMotionMoveToForce Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.TargetLocation_0 = std::move(TargetLocation_0);
|
|
Parms.Duration_0 = Duration_0;
|
|
Parms.bSetNewMovementMode_0 = bSetNewMovementMode_0;
|
|
Parms.MovementMode = MovementMode;
|
|
Parms.bRestrictSpeedToExpected_0 = bRestrictSpeedToExpected_0;
|
|
Parms.PathOffsetCurve_0 = PathOffsetCurve_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayEffectExecutionCalculation.Execute
|
|
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// const struct FGameplayEffectCustomExecutionParameters&ExecutionParams (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectCustomExecutionOutput*OutExecutionOutput (Parm, OutParm, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayEffectExecutionCalculation::Execute(const struct FGameplayEffectCustomExecutionParameters& ExecutionParams, struct FGameplayEffectCustomExecutionOutput* OutExecutionOutput) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayEffectExecutionCalculation", "Execute");
|
|
|
|
Params::GameplayEffectExecutionCalculation_Execute Parms{};
|
|
|
|
Parms.ExecutionParams = std::move(ExecutionParams);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutExecutionOutput != nullptr)
|
|
*OutExecutionOutput = std::move(Parms.OutExecutionOutput);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueInterface.BlueprintCustomHandler
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// EGameplayCueEvent EventType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void IGameplayCueInterface::BlueprintCustomHandler(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueInterface", "BlueprintCustomHandler");
|
|
|
|
Params::GameplayCueInterface_BlueprintCustomHandler Parms{};
|
|
|
|
Parms.EventType = EventType;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayCueInterface.ForwardGameplayCueToParent
|
|
// (BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
|
|
void IGameplayCueInterface::ForwardGameplayCueToParent()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayCueInterface", "ForwardGameplayCueToParent");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AbilityTargetDataFromActor
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayAbilityTargetDataHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetDataHandle UAbilitySystemBlueprintLibrary::AbilityTargetDataFromActor(class AActor* Actor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AbilityTargetDataFromActor");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AbilityTargetDataFromActor Parms{};
|
|
|
|
Parms.Actor = Actor;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AbilityTargetDataFromActorArray
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const TArray<class AActor*>& ActorArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool OneTargetPerHandle (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FGameplayAbilityTargetDataHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetDataHandle UAbilitySystemBlueprintLibrary::AbilityTargetDataFromActorArray(const TArray<class AActor*>& ActorArray, bool OneTargetPerHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AbilityTargetDataFromActorArray");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AbilityTargetDataFromActorArray Parms{};
|
|
|
|
Parms.ActorArray = std::move(ActorArray);
|
|
Parms.OneTargetPerHandle = OneTargetPerHandle;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AbilityTargetDataFromHitResult
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FHitResult& HitResult (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
// struct FGameplayAbilityTargetDataHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetDataHandle UAbilitySystemBlueprintLibrary::AbilityTargetDataFromHitResult(const struct FHitResult& HitResult)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AbilityTargetDataFromHitResult");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AbilityTargetDataFromHitResult Parms{};
|
|
|
|
Parms.HitResult = std::move(HitResult);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AbilityTargetDataFromLocations
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetingLocationInfo&SourceLocation (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityTargetingLocationInfo&TargetLocation (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
// struct FGameplayAbilityTargetDataHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetDataHandle UAbilitySystemBlueprintLibrary::AbilityTargetDataFromLocations(const struct FGameplayAbilityTargetingLocationInfo& SourceLocation, const struct FGameplayAbilityTargetingLocationInfo& TargetLocation)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AbilityTargetDataFromLocations");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AbilityTargetDataFromLocations Parms{};
|
|
|
|
Parms.SourceLocation = std::move(SourceLocation);
|
|
Parms.TargetLocation = std::move(TargetLocation);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AddAssetTag
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& NewGameplayTag (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::AddAssetTag(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& NewGameplayTag)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AddAssetTag");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AddAssetTag Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.NewGameplayTag = std::move(NewGameplayTag);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AddAssetTags
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagContainer& NewGameplayTags (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::AddAssetTags(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTagContainer& NewGameplayTags)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AddAssetTags");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AddAssetTags Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.NewGameplayTags = std::move(NewGameplayTags);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AddGrantedTag
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& NewGameplayTag (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::AddGrantedTag(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& NewGameplayTag)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AddGrantedTag");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AddGrantedTag Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.NewGameplayTag = std::move(NewGameplayTag);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AddGrantedTags
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagContainer& NewGameplayTags (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::AddGrantedTags(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTagContainer& NewGameplayTags)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AddGrantedTags");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AddGrantedTags Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.NewGameplayTags = std::move(NewGameplayTags);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AddLinkedGameplayEffectSpec
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEffectSpecHandle& LinkedGameplayEffectSpec (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::AddLinkedGameplayEffectSpec(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayEffectSpecHandle& LinkedGameplayEffectSpec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AddLinkedGameplayEffectSpec");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AddLinkedGameplayEffectSpec Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.LinkedGameplayEffectSpec = std::move(LinkedGameplayEffectSpec);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AppendTargetDataHandle
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAbilityTargetDataHandle&HandleToAdd (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayAbilityTargetDataHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetDataHandle UAbilitySystemBlueprintLibrary::AppendTargetDataHandle(const struct FGameplayAbilityTargetDataHandle& TargetHandle, const struct FGameplayAbilityTargetDataHandle& HandleToAdd)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AppendTargetDataHandle");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AppendTargetDataHandle Parms{};
|
|
|
|
Parms.TargetHandle = std::move(TargetHandle);
|
|
Parms.HandleToAdd = std::move(HandleToAdd);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.AssignSetByCallerMagnitude
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// class FName DataName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Magnitude (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::AssignSetByCallerMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, class FName DataName, float Magnitude)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "AssignSetByCallerMagnitude");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_AssignSetByCallerMagnitude Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.DataName = DataName;
|
|
Parms.Magnitude = Magnitude;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.DoesGameplayCueMeetTagRequirements
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayTagRequirements& SourceTagReqs (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayTagRequirements& TargetTagReqs (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::DoesGameplayCueMeetTagRequirements(const struct FGameplayCueParameters& Parameters, struct FGameplayTagRequirements& SourceTagReqs, struct FGameplayTagRequirements& TargetTagReqs)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "DoesGameplayCueMeetTagRequirements");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_DoesGameplayCueMeetTagRequirements Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
Parms.SourceTagReqs = std::move(SourceTagReqs);
|
|
Parms.TargetTagReqs = std::move(TargetTagReqs);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
SourceTagReqs = std::move(Parms.SourceTagReqs);
|
|
TargetTagReqs = std::move(Parms.TargetTagReqs);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.DoesTargetDataContainActor
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::DoesTargetDataContainActor(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX, class AActor* Actor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "DoesTargetDataContainActor");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_DoesTargetDataContainActor Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
Parms.Actor = Actor;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextGetEffectCauser
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class AActor* UAbilitySystemBlueprintLibrary::EffectContextGetEffectCauser(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextGetEffectCauser");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextGetEffectCauser Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextGetHitResult
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// struct FHitResult ReturnValue (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
struct FHitResult UAbilitySystemBlueprintLibrary::EffectContextGetHitResult(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextGetHitResult");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextGetHitResult Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextGetInstigatorActor
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class AActor* UAbilitySystemBlueprintLibrary::EffectContextGetInstigatorActor(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextGetInstigatorActor");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextGetInstigatorActor Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextGetOrigin
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// struct FVector ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FVector UAbilitySystemBlueprintLibrary::EffectContextGetOrigin(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextGetOrigin");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextGetOrigin Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextGetOriginalInstigatorActor
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class AActor* UAbilitySystemBlueprintLibrary::EffectContextGetOriginalInstigatorActor(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextGetOriginalInstigatorActor");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextGetOriginalInstigatorActor Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextGetSourceObject
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UObject* UAbilitySystemBlueprintLibrary::EffectContextGetSourceObject(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextGetSourceObject");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextGetSourceObject Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextHasHitResult
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::EffectContextHasHitResult(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextHasHitResult");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextHasHitResult Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextIsInstigatorLocallyControlled
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::EffectContextIsInstigatorLocallyControlled(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextIsInstigatorLocallyControlled");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextIsInstigatorLocallyControlled Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextIsValid
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::EffectContextIsValid(const struct FGameplayEffectContextHandle& EffectContext)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextIsValid");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextIsValid Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EffectContextSetOrigin
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectContextHandle&EffectContext (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FVector& Origin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemBlueprintLibrary::EffectContextSetOrigin(const struct FGameplayEffectContextHandle& EffectContext, const struct FVector& Origin)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EffectContextSetOrigin");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EffectContextSetOrigin Parms{};
|
|
|
|
Parms.EffectContext = std::move(EffectContext);
|
|
Parms.Origin = std::move(Origin);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EqualEqual_GameplayAttributeGameplayAttribute
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAttribute& AttributeA (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& AttributeB (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::EqualEqual_GameplayAttributeGameplayAttribute(const struct FGameplayAttribute& AttributeA, const struct FGameplayAttribute& AttributeB)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EqualEqual_GameplayAttributeGameplayAttribute");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EqualEqual_GameplayAttributeGameplayAttribute Parms{};
|
|
|
|
Parms.AttributeA = std::move(AttributeA);
|
|
Parms.AttributeB = std::move(AttributeB);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.EvaluateAttributeValueWithTags
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UAbilitySystemComponent* AbilitySystem (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& Attribute (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagContainer& SourceTags (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagContainer& TargetTags (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool* bSuccess (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAbilitySystemBlueprintLibrary::EvaluateAttributeValueWithTags(class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, const struct FGameplayTagContainer& SourceTags, const struct FGameplayTagContainer& TargetTags, bool* bSuccess)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "EvaluateAttributeValueWithTags");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_EvaluateAttributeValueWithTags Parms{};
|
|
|
|
Parms.AbilitySystem = AbilitySystem;
|
|
Parms.Attribute = std::move(Attribute);
|
|
Parms.SourceTags = std::move(SourceTags);
|
|
Parms.TargetTags = std::move(TargetTags);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (bSuccess != nullptr)
|
|
*bSuccess = Parms.bSuccess;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.FilterTargetData
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetDataHandle (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTargetDataFilterHandle&ActorFilterClass (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayAbilityTargetDataHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayAbilityTargetDataHandle UAbilitySystemBlueprintLibrary::FilterTargetData(const struct FGameplayAbilityTargetDataHandle& TargetDataHandle, const struct FGameplayTargetDataFilterHandle& ActorFilterClass)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "FilterTargetData");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_FilterTargetData Parms{};
|
|
|
|
Parms.TargetDataHandle = std::move(TargetDataHandle);
|
|
Parms.ActorFilterClass = std::move(ActorFilterClass);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.ForwardGameplayCueToTarget
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TScriptInterface<class IGameplayCueInterface>TargetCueInterface (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
|
|
// EGameplayCueEvent EventType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemBlueprintLibrary::ForwardGameplayCueToTarget(TScriptInterface<class IGameplayCueInterface> TargetCueInterface, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "ForwardGameplayCueToTarget");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_ForwardGameplayCueToTarget Parms{};
|
|
|
|
Parms.TargetCueInterface = TargetCueInterface;
|
|
Parms.EventType = EventType;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetAbilitySystemComponent
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilitySystemComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilitySystemComponent* UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(class AActor* Actor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetAbilitySystemComponent");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetAbilitySystemComponent Parms{};
|
|
|
|
Parms.Actor = Actor;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetActiveGameplayEffectDebugString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FActiveGameplayEffectHandle&ActiveHandle (Parm, NativeAccessSpecifierPublic)
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UAbilitySystemBlueprintLibrary::GetActiveGameplayEffectDebugString(const struct FActiveGameplayEffectHandle& ActiveHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetActiveGameplayEffectDebugString");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetActiveGameplayEffectDebugString Parms{};
|
|
|
|
Parms.ActiveHandle = std::move(ActiveHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetActiveGameplayEffectStackCount
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FActiveGameplayEffectHandle&ActiveHandle (Parm, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UAbilitySystemBlueprintLibrary::GetActiveGameplayEffectStackCount(const struct FActiveGameplayEffectHandle& ActiveHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetActiveGameplayEffectStackCount");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetActiveGameplayEffectStackCount Parms{};
|
|
|
|
Parms.ActiveHandle = std::move(ActiveHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetActiveGameplayEffectStackLimitCount
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FActiveGameplayEffectHandle&ActiveHandle (Parm, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UAbilitySystemBlueprintLibrary::GetActiveGameplayEffectStackLimitCount(const struct FActiveGameplayEffectHandle& ActiveHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetActiveGameplayEffectStackLimitCount");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetActiveGameplayEffectStackLimitCount Parms{};
|
|
|
|
Parms.ActiveHandle = std::move(ActiveHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetActorByIndex
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class AActor* UAbilitySystemBlueprintLibrary::GetActorByIndex(const struct FGameplayCueParameters& Parameters, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetActorByIndex");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetActorByIndex Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetActorCount
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UAbilitySystemBlueprintLibrary::GetActorCount(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetActorCount");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetActorCount Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetActorsFromTargetData
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<class AActor*> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<class AActor*> UAbilitySystemBlueprintLibrary::GetActorsFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetActorsFromTargetData");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetActorsFromTargetData Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetDataCountFromTargetData
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UAbilitySystemBlueprintLibrary::GetDataCountFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetDataCountFromTargetData");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetDataCountFromTargetData Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetEffectContext
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectContextHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectContextHandle UAbilitySystemBlueprintLibrary::GetEffectContext(const struct FGameplayEffectSpecHandle& SpecHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetEffectContext");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetEffectContext Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetFloatAttribute
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const class AActor* Actor (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& Attribute (Parm, NativeAccessSpecifierPublic)
|
|
// bool* bSuccessfullyFoundAttribute (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAbilitySystemBlueprintLibrary::GetFloatAttribute(const class AActor* Actor, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetFloatAttribute");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetFloatAttribute Parms{};
|
|
|
|
Parms.Actor = Actor;
|
|
Parms.Attribute = std::move(Attribute);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (bSuccessfullyFoundAttribute != nullptr)
|
|
*bSuccessfullyFoundAttribute = Parms.bSuccessfullyFoundAttribute;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetFloatAttributeFromAbilitySystemComponent
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const class UAbilitySystemComponent* AbilitySystem (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& Attribute (Parm, NativeAccessSpecifierPublic)
|
|
// bool* bSuccessfullyFoundAttribute (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAbilitySystemBlueprintLibrary::GetFloatAttributeFromAbilitySystemComponent(const class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetFloatAttributeFromAbilitySystemComponent");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetFloatAttributeFromAbilitySystemComponent Parms{};
|
|
|
|
Parms.AbilitySystem = AbilitySystem;
|
|
Parms.Attribute = std::move(Attribute);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (bSuccessfullyFoundAttribute != nullptr)
|
|
*bSuccessfullyFoundAttribute = Parms.bSuccessfullyFoundAttribute;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetGameplayCueDirection
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class AActor* TargetActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// struct FVector* Direction (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::GetGameplayCueDirection(class AActor* TargetActor, const struct FGameplayCueParameters& Parameters, struct FVector* Direction)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetGameplayCueDirection");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetGameplayCueDirection Parms{};
|
|
|
|
Parms.TargetActor = TargetActor;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Direction != nullptr)
|
|
*Direction = std::move(Parms.Direction);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetGameplayCueEndLocationAndNormal
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class AActor* TargetActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// struct FVector* Location (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FVector* Normal (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::GetGameplayCueEndLocationAndNormal(class AActor* TargetActor, const struct FGameplayCueParameters& Parameters, struct FVector* Location, struct FVector* Normal)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetGameplayCueEndLocationAndNormal");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetGameplayCueEndLocationAndNormal Parms{};
|
|
|
|
Parms.TargetActor = TargetActor;
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Location != nullptr)
|
|
*Location = std::move(Parms.Location);
|
|
|
|
if (Normal != nullptr)
|
|
*Normal = std::move(Parms.Normal);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetHitResult
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// struct FHitResult ReturnValue (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
struct FHitResult UAbilitySystemBlueprintLibrary::GetHitResult(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetHitResult");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetHitResult Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetHitResultFromTargetData
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&HitResult (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FHitResult ReturnValue (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
struct FHitResult UAbilitySystemBlueprintLibrary::GetHitResultFromTargetData(const struct FGameplayAbilityTargetDataHandle& HitResult, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetHitResultFromTargetData");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetHitResultFromTargetData Parms{};
|
|
|
|
Parms.HitResult = std::move(HitResult);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetInstigatorActor
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class AActor* UAbilitySystemBlueprintLibrary::GetInstigatorActor(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetInstigatorActor");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetInstigatorActor Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetInstigatorTransform
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FTransform UAbilitySystemBlueprintLibrary::GetInstigatorTransform(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetInstigatorTransform");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetInstigatorTransform Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetModifiedAttributeMagnitude
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& Attribute (Parm, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAbilitySystemBlueprintLibrary::GetModifiedAttributeMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayAttribute& Attribute)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetModifiedAttributeMagnitude");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetModifiedAttributeMagnitude Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.Attribute = std::move(Attribute);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetOrigin
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// struct FVector ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FVector UAbilitySystemBlueprintLibrary::GetOrigin(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetOrigin");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetOrigin Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetTargetDataEndPoint
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FVector UAbilitySystemBlueprintLibrary::GetTargetDataEndPoint(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetTargetDataEndPoint");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetTargetDataEndPoint Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetTargetDataEndPointTransform
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FTransform UAbilitySystemBlueprintLibrary::GetTargetDataEndPointTransform(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetTargetDataEndPointTransform");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetTargetDataEndPointTransform Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.GetTargetDataOrigin
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FTransform UAbilitySystemBlueprintLibrary::GetTargetDataOrigin(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "GetTargetDataOrigin");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_GetTargetDataOrigin Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.HasHitResult
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::HasHitResult(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "HasHitResult");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_HasHitResult Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.IsInstigatorLocallyControlled
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::IsInstigatorLocallyControlled(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "IsInstigatorLocallyControlled");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_IsInstigatorLocallyControlled Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.IsInstigatorLocallyControlledPlayer
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayCueParameters& Parameters (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::IsInstigatorLocallyControlledPlayer(const struct FGameplayCueParameters& Parameters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "IsInstigatorLocallyControlledPlayer");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_IsInstigatorLocallyControlledPlayer Parms{};
|
|
|
|
Parms.Parameters = std::move(Parameters);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.MakeFilterHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayTargetDataFilter& Filter (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* FilterActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayTargetDataFilterHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayTargetDataFilterHandle UAbilitySystemBlueprintLibrary::MakeFilterHandle(const struct FGameplayTargetDataFilter& Filter, class AActor* FilterActor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "MakeFilterHandle");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_MakeFilterHandle Parms{};
|
|
|
|
Parms.Filter = std::move(Filter);
|
|
Parms.FilterActor = FilterActor;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.MakeSpecHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UGameplayEffect* InGameplayEffect (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AActor* InInstigator (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AActor* InEffectCauser (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::MakeSpecHandle(class UGameplayEffect* InGameplayEffect, class AActor* InInstigator, class AActor* InEffectCauser, float InLevel)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "MakeSpecHandle");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_MakeSpecHandle Parms{};
|
|
|
|
Parms.InGameplayEffect = InGameplayEffect;
|
|
Parms.InInstigator = InInstigator;
|
|
Parms.InEffectCauser = InEffectCauser;
|
|
Parms.InLevel = InLevel;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.NotEqual_GameplayAttributeGameplayAttribute
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAttribute& AttributeA (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayAttribute& AttributeB (Parm, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::NotEqual_GameplayAttributeGameplayAttribute(const struct FGameplayAttribute& AttributeA, const struct FGameplayAttribute& AttributeB)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "NotEqual_GameplayAttributeGameplayAttribute");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_NotEqual_GameplayAttributeGameplayAttribute Parms{};
|
|
|
|
Parms.AttributeA = std::move(AttributeA);
|
|
Parms.AttributeB = std::move(AttributeB);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.SendGameplayEventToActor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& EventTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayEventData& Payload (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilitySystemBlueprintLibrary::SendGameplayEventToActor(class AActor* Actor, const struct FGameplayTag& EventTag, const struct FGameplayEventData& Payload)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "SendGameplayEventToActor");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_SendGameplayEventToActor Parms{};
|
|
|
|
Parms.Actor = Actor;
|
|
Parms.EventTag = std::move(EventTag);
|
|
Parms.Payload = std::move(Payload);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.SetDuration
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::SetDuration(const struct FGameplayEffectSpecHandle& SpecHandle, float Duration)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "SetDuration");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_SetDuration Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.Duration = Duration;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.SetStackCount
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// int32 StackCount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::SetStackCount(const struct FGameplayEffectSpecHandle& SpecHandle, int32 StackCount)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "SetStackCount");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_SetStackCount Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
Parms.StackCount = StackCount;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.SetStackCountToMax
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpecHandle& SpecHandle (Parm, NativeAccessSpecifierPublic)
|
|
// struct FGameplayEffectSpecHandle ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::SetStackCountToMax(const struct FGameplayEffectSpecHandle& SpecHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "SetStackCountToMax");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_SetStackCountToMax Parms{};
|
|
|
|
Parms.SpecHandle = std::move(SpecHandle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.TargetDataHasActor
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::TargetDataHasActor(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "TargetDataHasActor");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_TargetDataHasActor Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.TargetDataHasEndPoint
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::TargetDataHasEndPoint(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "TargetDataHasEndPoint");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_TargetDataHasEndPoint Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.TargetDataHasHitResult
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&HitResult (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::TargetDataHasHitResult(const struct FGameplayAbilityTargetDataHandle& HitResult, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "TargetDataHasHitResult");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_TargetDataHasHitResult Parms{};
|
|
|
|
Parms.HitResult = std::move(HitResult);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilitySystemBlueprintLibrary.TargetDataHasOrigin
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&TargetData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 INDEX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilitySystemBlueprintLibrary::TargetDataHasOrigin(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 INDEX)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilitySystemBlueprintLibrary", "TargetDataHasOrigin");
|
|
|
|
Params::AbilitySystemBlueprintLibrary_TargetDataHasOrigin Parms{};
|
|
|
|
Parms.TargetData = std::move(TargetData);
|
|
Parms.INDEX = INDEX;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_ApplyRootMotionConstantForce.ApplyRootMotionConstantForce
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector& WorldDirection_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Strength_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Duration_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bIsAdditive_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool bDisableImpartingVelocityOnRemoval_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_ApplyRootMotionConstantForce*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_ApplyRootMotionConstantForce* UAbilityTask_ApplyRootMotionConstantForce::ApplyRootMotionConstantForce(class UObject* WorldContextObject, class FName TaskInstanceName, const struct FVector& WorldDirection_0, float Strength_0, float Duration_0, bool bIsAdditive_0, bool bDisableImpartingVelocityOnRemoval_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_ApplyRootMotionConstantForce", "ApplyRootMotionConstantForce");
|
|
|
|
Params::AbilityTask_ApplyRootMotionConstantForce_ApplyRootMotionConstantForce Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.WorldDirection_0 = std::move(WorldDirection_0);
|
|
Parms.Strength_0 = Strength_0;
|
|
Parms.Duration_0 = Duration_0;
|
|
Parms.bIsAdditive_0 = bIsAdditive_0;
|
|
Parms.bDisableImpartingVelocityOnRemoval_0 = bDisableImpartingVelocityOnRemoval_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_ApplyRootMotionJumpForce.ApplyRootMotionJumpForce
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FRotator& Rotation_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Distance_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Height_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Duration_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float MinimumLandedTriggerTime_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bFinishOnLanded_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UCurveVector* PathOffsetCurve_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UCurveFloat* TimeMappingCurve_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_ApplyRootMotionJumpForce*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_ApplyRootMotionJumpForce* UAbilityTask_ApplyRootMotionJumpForce::ApplyRootMotionJumpForce(class UObject* WorldContextObject, class FName TaskInstanceName, const struct FRotator& Rotation_0, float Distance_0, float Height_0, float Duration_0, float MinimumLandedTriggerTime_0, bool bFinishOnLanded_0, class UCurveVector* PathOffsetCurve_0, class UCurveFloat* TimeMappingCurve_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_ApplyRootMotionJumpForce", "ApplyRootMotionJumpForce");
|
|
|
|
Params::AbilityTask_ApplyRootMotionJumpForce_ApplyRootMotionJumpForce Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.Rotation_0 = std::move(Rotation_0);
|
|
Parms.Distance_0 = Distance_0;
|
|
Parms.Height_0 = Height_0;
|
|
Parms.Duration_0 = Duration_0;
|
|
Parms.MinimumLandedTriggerTime_0 = MinimumLandedTriggerTime_0;
|
|
Parms.bFinishOnLanded_0 = bFinishOnLanded_0;
|
|
Parms.PathOffsetCurve_0 = PathOffsetCurve_0;
|
|
Parms.TimeMappingCurve_0 = TimeMappingCurve_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_ApplyRootMotionJumpForce.Finish
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAbilityTask_ApplyRootMotionJumpForce::Finish()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_ApplyRootMotionJumpForce", "Finish");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_ApplyRootMotionJumpForce.OnLandedCallback
|
|
// (Final, Native, Public, HasOutParams)
|
|
// Parameters:
|
|
// const struct FHitResult& Hit (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_ApplyRootMotionJumpForce::OnLandedCallback(const struct FHitResult& Hit)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_ApplyRootMotionJumpForce", "OnLandedCallback");
|
|
|
|
Params::AbilityTask_ApplyRootMotionJumpForce_OnLandedCallback Parms{};
|
|
|
|
Parms.Hit = std::move(Hit);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_ApplyRootMotionRadialForce.ApplyRootMotionRadialForce
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector& Location_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class AActor* LocationActor_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Strength_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Duration_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Radius_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bIsPush_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool bIsAdditive_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool bNoZForce_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UCurveFloat* StrengthDistanceFalloff_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UCurveFloat* StrengthOverTime_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_ApplyRootMotionRadialForce*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_ApplyRootMotionRadialForce* UAbilityTask_ApplyRootMotionRadialForce::ApplyRootMotionRadialForce(class UObject* WorldContextObject, 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)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_ApplyRootMotionRadialForce", "ApplyRootMotionRadialForce");
|
|
|
|
Params::AbilityTask_ApplyRootMotionRadialForce_ApplyRootMotionRadialForce Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.Location_0 = std::move(Location_0);
|
|
Parms.LocationActor_0 = LocationActor_0;
|
|
Parms.Strength_0 = Strength_0;
|
|
Parms.Duration_0 = Duration_0;
|
|
Parms.Radius_0 = Radius_0;
|
|
Parms.bIsPush_0 = bIsPush_0;
|
|
Parms.bIsAdditive_0 = bIsAdditive_0;
|
|
Parms.bNoZForce_0 = bNoZForce_0;
|
|
Parms.StrengthDistanceFalloff_0 = StrengthDistanceFalloff_0;
|
|
Parms.StrengthOverTime_0 = StrengthOverTime_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_MoveToLocation.MoveToLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector& Location (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UCurveFloat* OptionalInterpolationCurve (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UCurveVector* OptionalVectorInterpolationCurve (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_MoveToLocation* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_MoveToLocation* UAbilityTask_MoveToLocation::MoveToLocation(class UObject* WorldContextObject, class FName TaskInstanceName, const struct FVector& Location, float Duration, class UCurveFloat* OptionalInterpolationCurve, class UCurveVector* OptionalVectorInterpolationCurve)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_MoveToLocation", "MoveToLocation");
|
|
|
|
Params::AbilityTask_MoveToLocation_MoveToLocation Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.Location = std::move(Location);
|
|
Parms.Duration = Duration;
|
|
Parms.OptionalInterpolationCurve = OptionalInterpolationCurve;
|
|
Parms.OptionalVectorInterpolationCurve = OptionalVectorInterpolationCurve;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_NetworkSyncPoint.WaitNetSync
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EAbilityTaskNetSyncType SyncType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_NetworkSyncPoint* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_NetworkSyncPoint* UAbilityTask_NetworkSyncPoint::WaitNetSync(class UObject* WorldContextObject, EAbilityTaskNetSyncType SyncType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_NetworkSyncPoint", "WaitNetSync");
|
|
|
|
Params::AbilityTask_NetworkSyncPoint_WaitNetSync Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SyncType = SyncType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_NetworkSyncPoint.OnSignalCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_NetworkSyncPoint::OnSignalCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_NetworkSyncPoint", "OnSignalCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_PlayMontageAndWait.CreatePlayMontageAndWaitProxy
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAnimMontage* MontageToPlay (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Rate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName StartSection (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bStopWhenAbilityEnds (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float AnimRootMotionTranslationScale (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_PlayMontageAndWait* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_PlayMontageAndWait* UAbilityTask_PlayMontageAndWait::CreatePlayMontageAndWaitProxy(class UObject* WorldContextObject, class FName TaskInstanceName, class UAnimMontage* MontageToPlay, float Rate, class FName StartSection, bool bStopWhenAbilityEnds, float AnimRootMotionTranslationScale)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_PlayMontageAndWait", "CreatePlayMontageAndWaitProxy");
|
|
|
|
Params::AbilityTask_PlayMontageAndWait_CreatePlayMontageAndWaitProxy Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.MontageToPlay = MontageToPlay;
|
|
Parms.Rate = Rate;
|
|
Parms.StartSection = StartSection;
|
|
Parms.bStopWhenAbilityEnds = bStopWhenAbilityEnds;
|
|
Parms.AnimRootMotionTranslationScale = AnimRootMotionTranslationScale;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_PlayMontageAndWait.OnMontageBlendingOut
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bInterrupted (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_PlayMontageAndWait::OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_PlayMontageAndWait", "OnMontageBlendingOut");
|
|
|
|
Params::AbilityTask_PlayMontageAndWait_OnMontageBlendingOut Parms{};
|
|
|
|
Parms.Montage = Montage;
|
|
Parms.bInterrupted = bInterrupted;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_PlayMontageAndWait.OnMontageInterrupted
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_PlayMontageAndWait::OnMontageInterrupted()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_PlayMontageAndWait", "OnMontageInterrupted");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_Repeat.RepeatAction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float TimeBetweenActions (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 TotalActionCount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_Repeat* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_Repeat* UAbilityTask_Repeat::RepeatAction(class UObject* WorldContextObject, float TimeBetweenActions, int32 TotalActionCount)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_Repeat", "RepeatAction");
|
|
|
|
Params::AbilityTask_Repeat_RepeatAction Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TimeBetweenActions = TimeBetweenActions;
|
|
Parms.TotalActionCount = TotalActionCount;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_StartAbilityState.StartAbilityState
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName StateName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bEndCurrentState (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_StartAbilityState* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_StartAbilityState* UAbilityTask_StartAbilityState::StartAbilityState(class UObject* WorldContextObject, class FName StateName, bool bEndCurrentState)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_StartAbilityState", "StartAbilityState");
|
|
|
|
Params::AbilityTask_StartAbilityState_StartAbilityState Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.StateName = StateName;
|
|
Parms.bEndCurrentState = bEndCurrentState;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_VisualizeTargeting.VisualizeTargeting
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class AGameplayAbilityTargetActor>Class_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_VisualizeTargeting* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_VisualizeTargeting* UAbilityTask_VisualizeTargeting::VisualizeTargeting(class UObject* WorldContextObject, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class FName TaskInstanceName, float Duration)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_VisualizeTargeting", "VisualizeTargeting");
|
|
|
|
Params::AbilityTask_VisualizeTargeting_VisualizeTargeting Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Class_0 = Class_0;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.Duration = Duration;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_VisualizeTargeting.VisualizeTargetingUsingActor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AGameplayAbilityTargetActor* TargetActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_VisualizeTargeting* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_VisualizeTargeting* UAbilityTask_VisualizeTargeting::VisualizeTargetingUsingActor(class UObject* WorldContextObject, class AGameplayAbilityTargetActor* TargetActor, class FName TaskInstanceName, float Duration)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_VisualizeTargeting", "VisualizeTargetingUsingActor");
|
|
|
|
Params::AbilityTask_VisualizeTargeting_VisualizeTargetingUsingActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TargetActor = TargetActor;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.Duration = Duration;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_VisualizeTargeting.BeginSpawningActor
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class AGameplayAbilityTargetActor>Class_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AGameplayAbilityTargetActor** SpawnedActor (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilityTask_VisualizeTargeting::BeginSpawningActor(class UObject* WorldContextObject, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class AGameplayAbilityTargetActor** SpawnedActor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_VisualizeTargeting", "BeginSpawningActor");
|
|
|
|
Params::AbilityTask_VisualizeTargeting_BeginSpawningActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Class_0 = Class_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (SpawnedActor != nullptr)
|
|
*SpawnedActor = Parms.SpawnedActor;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_VisualizeTargeting.FinishSpawningActor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AGameplayAbilityTargetActor* SpawnedActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_VisualizeTargeting::FinishSpawningActor(class UObject* WorldContextObject, class AGameplayAbilityTargetActor* SpawnedActor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_VisualizeTargeting", "FinishSpawningActor");
|
|
|
|
Params::AbilityTask_VisualizeTargeting_FinishSpawningActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SpawnedActor = SpawnedActor;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitAbilityActivate.WaitForAbilityActivate
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& WithTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& WithoutTag (Parm, NativeAccessSpecifierPublic)
|
|
// bool IncludeTriggeredAbilities (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool TriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitAbilityActivate* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitAbilityActivate* UAbilityTask_WaitAbilityActivate::WaitForAbilityActivate(class UObject* WorldContextObject, const struct FGameplayTag& WithTag, const struct FGameplayTag& WithoutTag, bool IncludeTriggeredAbilities, bool TriggerOnce)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitAbilityActivate", "WaitForAbilityActivate");
|
|
|
|
Params::AbilityTask_WaitAbilityActivate_WaitForAbilityActivate Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.WithTag = std::move(WithTag);
|
|
Parms.WithoutTag = std::move(WithoutTag);
|
|
Parms.IncludeTriggeredAbilities = IncludeTriggeredAbilities;
|
|
Parms.TriggerOnce = TriggerOnce;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitAbilityActivate.OnAbilityActivate
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class UGameplayAbility* ActivatedAbility (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitAbilityActivate::OnAbilityActivate(class UGameplayAbility* ActivatedAbility)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitAbilityActivate", "OnAbilityActivate");
|
|
|
|
Params::AbilityTask_WaitAbilityActivate_OnAbilityActivate Parms{};
|
|
|
|
Parms.ActivatedAbility = ActivatedAbility;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitAbilityCommit.WaitForAbilityCommit
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& WithTag (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& WithoutTage (Parm, NativeAccessSpecifierPublic)
|
|
// bool TriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitAbilityCommit* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitAbilityCommit* UAbilityTask_WaitAbilityCommit::WaitForAbilityCommit(class UObject* WorldContextObject, const struct FGameplayTag& WithTag, const struct FGameplayTag& WithoutTage, bool TriggerOnce)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitAbilityCommit", "WaitForAbilityCommit");
|
|
|
|
Params::AbilityTask_WaitAbilityCommit_WaitForAbilityCommit Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.WithTag = std::move(WithTag);
|
|
Parms.WithoutTage = std::move(WithoutTage);
|
|
Parms.TriggerOnce = TriggerOnce;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitAbilityCommit.OnAbilityCommit
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class UGameplayAbility* ActivatedAbility (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitAbilityCommit::OnAbilityCommit(class UGameplayAbility* ActivatedAbility)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitAbilityCommit", "OnAbilityCommit");
|
|
|
|
Params::AbilityTask_WaitAbilityCommit_OnAbilityCommit Parms{};
|
|
|
|
Parms.ActivatedAbility = ActivatedAbility;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitCancel.WaitCancel
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitCancel* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitCancel* UAbilityTask_WaitCancel::WaitCancel(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitCancel", "WaitCancel");
|
|
|
|
Params::AbilityTask_WaitCancel_WaitCancel Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitCancel.OnCancelCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitCancel::OnCancelCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitCancel", "OnCancelCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitCancel.OnLocalCancelCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitCancel::OnLocalCancelCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitCancel", "OnLocalCancelCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitConfirm.WaitConfirm
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitConfirm* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitConfirm* UAbilityTask_WaitConfirm::WaitConfirm(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitConfirm", "WaitConfirm");
|
|
|
|
Params::AbilityTask_WaitConfirm_WaitConfirm Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitConfirm.OnConfirmCallback
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class UGameplayAbility* InAbility (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitConfirm::OnConfirmCallback(class UGameplayAbility* InAbility)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitConfirm", "OnConfirmCallback");
|
|
|
|
Params::AbilityTask_WaitConfirm_OnConfirmCallback Parms{};
|
|
|
|
Parms.InAbility = InAbility;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitConfirmCancel.WaitConfirmCancel
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitConfirmCancel* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitConfirmCancel* UAbilityTask_WaitConfirmCancel::WaitConfirmCancel(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitConfirmCancel", "WaitConfirmCancel");
|
|
|
|
Params::AbilityTask_WaitConfirmCancel_WaitConfirmCancel Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitConfirmCancel.OnCancelCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitConfirmCancel::OnCancelCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitConfirmCancel", "OnCancelCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitConfirmCancel.OnConfirmCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitConfirmCancel::OnConfirmCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitConfirmCancel", "OnConfirmCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitConfirmCancel.OnLocalCancelCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitConfirmCancel::OnLocalCancelCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitConfirmCancel", "OnLocalCancelCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitConfirmCancel.OnLocalConfirmCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitConfirmCancel::OnLocalConfirmCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitConfirmCancel", "OnLocalConfirmCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitDelay.WaitDelay
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitDelay* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitDelay* UAbilityTask_WaitDelay::WaitDelay(class UObject* WorldContextObject, float Time)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitDelay", "WaitDelay");
|
|
|
|
Params::AbilityTask_WaitDelay_WaitDelay Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Time = Time;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEffectApplied_Self.WaitGameplayEffectAppliedToSelf
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTargetDataFilterHandle&SourceFilter (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagRequirements& SourceTagRequirements (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagRequirements& TargetTagRequirements (Parm, NativeAccessSpecifierPublic)
|
|
// bool TriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class AActor* OptionalExternalOwner (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ListenForPeriodicEffect (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitGameplayEffectApplied_Self*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitGameplayEffectApplied_Self* UAbilityTask_WaitGameplayEffectApplied_Self::WaitGameplayEffectAppliedToSelf(class UObject* WorldContextObject, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffect)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitGameplayEffectApplied_Self", "WaitGameplayEffectAppliedToSelf");
|
|
|
|
Params::AbilityTask_WaitGameplayEffectApplied_Self_WaitGameplayEffectAppliedToSelf Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SourceFilter = std::move(SourceFilter);
|
|
Parms.SourceTagRequirements = std::move(SourceTagRequirements);
|
|
Parms.TargetTagRequirements = std::move(TargetTagRequirements);
|
|
Parms.TriggerOnce = TriggerOnce;
|
|
Parms.OptionalExternalOwner = OptionalExternalOwner;
|
|
Parms.ListenForPeriodicEffect = ListenForPeriodicEffect;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEffectApplied_Target.WaitGameplayEffectAppliedToTarget
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTargetDataFilterHandle&TargetFilter (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagRequirements& SourceTagRequirements (Parm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTagRequirements& TargetTagRequirements (Parm, NativeAccessSpecifierPublic)
|
|
// bool TriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class AActor* OptionalExternalOwner (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ListenForPeriodicEffects (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitGameplayEffectApplied_Target*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitGameplayEffectApplied_Target* UAbilityTask_WaitGameplayEffectApplied_Target::WaitGameplayEffectAppliedToTarget(class UObject* WorldContextObject, const struct FGameplayTargetDataFilterHandle& TargetFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffects)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitGameplayEffectApplied_Target", "WaitGameplayEffectAppliedToTarget");
|
|
|
|
Params::AbilityTask_WaitGameplayEffectApplied_Target_WaitGameplayEffectAppliedToTarget Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TargetFilter = std::move(TargetFilter);
|
|
Parms.SourceTagRequirements = std::move(SourceTagRequirements);
|
|
Parms.TargetTagRequirements = std::move(TargetTagRequirements);
|
|
Parms.TriggerOnce = TriggerOnce;
|
|
Parms.OptionalExternalOwner = OptionalExternalOwner;
|
|
Parms.ListenForPeriodicEffects = ListenForPeriodicEffects;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEffectStackChange.WaitForGameplayEffectStackChange
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FActiveGameplayEffectHandle&Handle (Parm, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitGameplayEffectStackChange*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitGameplayEffectStackChange* UAbilityTask_WaitGameplayEffectStackChange::WaitForGameplayEffectStackChange(class UObject* WorldContextObject, const struct FActiveGameplayEffectHandle& Handle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitGameplayEffectStackChange", "WaitForGameplayEffectStackChange");
|
|
|
|
Params::AbilityTask_WaitGameplayEffectStackChange_WaitForGameplayEffectStackChange Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Handle = std::move(Handle);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEffectStackChange.OnGameplayEffectStackChange
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// const struct FActiveGameplayEffectHandle&Handle (Parm, NativeAccessSpecifierPublic)
|
|
// int32 NewCount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 OldCount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitGameplayEffectStackChange::OnGameplayEffectStackChange(const struct FActiveGameplayEffectHandle& Handle, int32 NewCount, int32 OldCount)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitGameplayEffectStackChange", "OnGameplayEffectStackChange");
|
|
|
|
Params::AbilityTask_WaitGameplayEffectStackChange_OnGameplayEffectStackChange Parms{};
|
|
|
|
Parms.Handle = std::move(Handle);
|
|
Parms.NewCount = NewCount;
|
|
Parms.OldCount = OldCount;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayEvent.WaitGameplayEvent
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& EventTag (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* OptionalExternalTarget_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool OnlyTriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitGameplayEvent* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitGameplayEvent* UAbilityTask_WaitGameplayEvent::WaitGameplayEvent(class UObject* WorldContextObject, const struct FGameplayTag& EventTag, class AActor* OptionalExternalTarget_0, bool OnlyTriggerOnce)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitGameplayEvent", "WaitGameplayEvent");
|
|
|
|
Params::AbilityTask_WaitGameplayEvent_WaitGameplayEvent Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.EventTag = std::move(EventTag);
|
|
Parms.OptionalExternalTarget_0 = OptionalExternalTarget_0;
|
|
Parms.OnlyTriggerOnce = OnlyTriggerOnce;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayTag.GameplayTagCallback
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// const struct FGameplayTag& Tag (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// int32 NewCount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitGameplayTag::GameplayTagCallback(const struct FGameplayTag& Tag, int32 NewCount)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitGameplayTag", "GameplayTagCallback");
|
|
|
|
Params::AbilityTask_WaitGameplayTag_GameplayTagCallback Parms{};
|
|
|
|
Parms.Tag = std::move(Tag);
|
|
Parms.NewCount = NewCount;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayTagAdded.WaitGameplayTagAdd
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& Tag (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* InOptionalExternalTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool OnlyTriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitGameplayTagAdded*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitGameplayTagAdded* UAbilityTask_WaitGameplayTagAdded::WaitGameplayTagAdd(class UObject* WorldContextObject, const struct FGameplayTag& Tag, class AActor* InOptionalExternalTarget, bool OnlyTriggerOnce)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitGameplayTagAdded", "WaitGameplayTagAdd");
|
|
|
|
Params::AbilityTask_WaitGameplayTagAdded_WaitGameplayTagAdd Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Tag = std::move(Tag);
|
|
Parms.InOptionalExternalTarget = InOptionalExternalTarget;
|
|
Parms.OnlyTriggerOnce = OnlyTriggerOnce;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitGameplayTagRemoved.WaitGameplayTagRemove
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& Tag (Parm, NativeAccessSpecifierPublic)
|
|
// class AActor* InOptionalExternalTarget (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool OnlyTriggerOnce (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitGameplayTagRemoved*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitGameplayTagRemoved* UAbilityTask_WaitGameplayTagRemoved::WaitGameplayTagRemove(class UObject* WorldContextObject, const struct FGameplayTag& Tag, class AActor* InOptionalExternalTarget, bool OnlyTriggerOnce)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitGameplayTagRemoved", "WaitGameplayTagRemove");
|
|
|
|
Params::AbilityTask_WaitGameplayTagRemoved_WaitGameplayTagRemove Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Tag = std::move(Tag);
|
|
Parms.InOptionalExternalTarget = InOptionalExternalTarget;
|
|
Parms.OnlyTriggerOnce = OnlyTriggerOnce;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitInputRelease.WaitInputRelease
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bTestAlreadyReleased (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitInputRelease* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitInputRelease* UAbilityTask_WaitInputRelease::WaitInputRelease(class UObject* WorldContextObject, bool bTestAlreadyReleased)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitInputRelease", "WaitInputRelease");
|
|
|
|
Params::AbilityTask_WaitInputRelease_WaitInputRelease Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.bTestAlreadyReleased = bTestAlreadyReleased;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitInputRelease.OnReleaseCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitInputRelease::OnReleaseCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitInputRelease", "OnReleaseCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitMovementModeChange.CreateWaitMovementModeChange
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EMovementMode NewMode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitMovementModeChange*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitMovementModeChange* UAbilityTask_WaitMovementModeChange::CreateWaitMovementModeChange(class UObject* WorldContextObject, EMovementMode NewMode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitMovementModeChange", "CreateWaitMovementModeChange");
|
|
|
|
Params::AbilityTask_WaitMovementModeChange_CreateWaitMovementModeChange Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.NewMode = NewMode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitMovementModeChange.OnMovementModeChange
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class ACharacter* Character (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EMovementMode PrevMovementMode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// uint8 PreviousCustomMode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitMovementModeChange::OnMovementModeChange(class ACharacter* Character, EMovementMode PrevMovementMode, uint8 PreviousCustomMode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitMovementModeChange", "OnMovementModeChange");
|
|
|
|
Params::AbilityTask_WaitMovementModeChange_OnMovementModeChange Parms{};
|
|
|
|
Parms.Character = Character;
|
|
Parms.PrevMovementMode = PrevMovementMode;
|
|
Parms.PreviousCustomMode = PreviousCustomMode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.WaitTargetData
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EGameplayTargetingConfirmation ConfirmationType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class AGameplayAbilityTargetActor>Class_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitTargetData* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitTargetData* UAbilityTask_WaitTargetData::WaitTargetData(class UObject* WorldContextObject, class FName TaskInstanceName, EGameplayTargetingConfirmation ConfirmationType, TSubclassOf<class AGameplayAbilityTargetActor> Class_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitTargetData", "WaitTargetData");
|
|
|
|
Params::AbilityTask_WaitTargetData_WaitTargetData Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.ConfirmationType = ConfirmationType;
|
|
Parms.Class_0 = Class_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.WaitTargetDataUsingActor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName TaskInstanceName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EGameplayTargetingConfirmation ConfirmationType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AGameplayAbilityTargetActor* TargetActor_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitTargetData* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitTargetData* UAbilityTask_WaitTargetData::WaitTargetDataUsingActor(class UObject* WorldContextObject, class FName TaskInstanceName, EGameplayTargetingConfirmation ConfirmationType, class AGameplayAbilityTargetActor* TargetActor_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitTargetData", "WaitTargetDataUsingActor");
|
|
|
|
Params::AbilityTask_WaitTargetData_WaitTargetDataUsingActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.TaskInstanceName = TaskInstanceName;
|
|
Parms.ConfirmationType = ConfirmationType;
|
|
Parms.TargetActor_0 = TargetActor_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.BeginSpawningActor
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TSubclassOf<class AGameplayAbilityTargetActor>Class_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AGameplayAbilityTargetActor** SpawnedActor (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
bool UAbilityTask_WaitTargetData::BeginSpawningActor(class UObject* WorldContextObject, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class AGameplayAbilityTargetActor** SpawnedActor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitTargetData", "BeginSpawningActor");
|
|
|
|
Params::AbilityTask_WaitTargetData_BeginSpawningActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Class_0 = Class_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (SpawnedActor != nullptr)
|
|
*SpawnedActor = Parms.SpawnedActor;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.FinishSpawningActor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class AGameplayAbilityTargetActor* SpawnedActor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitTargetData::FinishSpawningActor(class UObject* WorldContextObject, class AGameplayAbilityTargetActor* SpawnedActor)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitTargetData", "FinishSpawningActor");
|
|
|
|
Params::AbilityTask_WaitTargetData_FinishSpawningActor Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SpawnedActor = SpawnedActor;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.OnTargetDataCancelledCallback
|
|
// (Final, Native, Public, HasOutParams)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&Data (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitTargetData::OnTargetDataCancelledCallback(const struct FGameplayAbilityTargetDataHandle& Data)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitTargetData", "OnTargetDataCancelledCallback");
|
|
|
|
Params::AbilityTask_WaitTargetData_OnTargetDataCancelledCallback Parms{};
|
|
|
|
Parms.Data = std::move(Data);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.OnTargetDataReadyCallback
|
|
// (Final, Native, Public, HasOutParams)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&Data (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitTargetData::OnTargetDataReadyCallback(const struct FGameplayAbilityTargetDataHandle& Data)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitTargetData", "OnTargetDataReadyCallback");
|
|
|
|
Params::AbilityTask_WaitTargetData_OnTargetDataReadyCallback Parms{};
|
|
|
|
Parms.Data = std::move(Data);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.OnTargetDataReplicatedCallback
|
|
// (Final, Native, Public, HasOutParams)
|
|
// Parameters:
|
|
// const struct FGameplayAbilityTargetDataHandle&Data (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const struct FGameplayTag& ActivationTag (Parm, NativeAccessSpecifierPublic)
|
|
|
|
void UAbilityTask_WaitTargetData::OnTargetDataReplicatedCallback(const struct FGameplayAbilityTargetDataHandle& Data, const struct FGameplayTag& ActivationTag)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitTargetData", "OnTargetDataReplicatedCallback");
|
|
|
|
Params::AbilityTask_WaitTargetData_OnTargetDataReplicatedCallback Parms{};
|
|
|
|
Parms.Data = std::move(Data);
|
|
Parms.ActivationTag = std::move(ActivationTag);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitTargetData.OnTargetDataReplicatedCancelledCallback
|
|
// (Final, Native, Public)
|
|
|
|
void UAbilityTask_WaitTargetData::OnTargetDataReplicatedCancelledCallback()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("AbilityTask_WaitTargetData", "OnTargetDataReplicatedCancelledCallback");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.AbilityTask_WaitVelocityChange.CreateWaitVelocityChange
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector& Direction (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float MinimumMagnitude (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilityTask_WaitVelocityChange* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAbilityTask_WaitVelocityChange* UAbilityTask_WaitVelocityChange::CreateWaitVelocityChange(class UObject* WorldContextObject, const struct FVector& Direction, float MinimumMagnitude)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("AbilityTask_WaitVelocityChange", "CreateWaitVelocityChange");
|
|
|
|
Params::AbilityTask_WaitVelocityChange_CreateWaitVelocityChange Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Direction = std::move(Direction);
|
|
Parms.MinimumMagnitude = MinimumMagnitude;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityWorldReticle.FaceTowardSource
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bFaceIn2D (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void AGameplayAbilityWorldReticle::FaceTowardSource(bool bFaceIn2D)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityWorldReticle", "FaceTowardSource");
|
|
|
|
Params::GameplayAbilityWorldReticle_FaceTowardSource Parms{};
|
|
|
|
Parms.bFaceIn2D = bFaceIn2D;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityWorldReticle.OnParametersInitialized
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void AGameplayAbilityWorldReticle::OnParametersInitialized()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityWorldReticle", "OnParametersInitialized");
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityWorldReticle.OnTargetingAnActor
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void AGameplayAbilityWorldReticle::OnTargetingAnActor(bool bNewValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityWorldReticle", "OnTargetingAnActor");
|
|
|
|
Params::GameplayAbilityWorldReticle_OnTargetingAnActor Parms{};
|
|
|
|
Parms.bNewValue = bNewValue;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityWorldReticle.OnValidTargetChanged
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void AGameplayAbilityWorldReticle::OnValidTargetChanged(bool bNewValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityWorldReticle", "OnValidTargetChanged");
|
|
|
|
Params::GameplayAbilityWorldReticle_OnValidTargetChanged Parms{};
|
|
|
|
Parms.bNewValue = bNewValue;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityWorldReticle.SetReticleMaterialParamFloat
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class FName ParamName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void AGameplayAbilityWorldReticle::SetReticleMaterialParamFloat(class FName ParamName, float Value)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityWorldReticle", "SetReticleMaterialParamFloat");
|
|
|
|
Params::GameplayAbilityWorldReticle_SetReticleMaterialParamFloat Parms{};
|
|
|
|
Parms.ParamName = ParamName;
|
|
Parms.Value = Value;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayAbilityWorldReticle.SetReticleMaterialParamVector
|
|
// (Event, Public, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// class FName ParamName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector& Value (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void AGameplayAbilityWorldReticle::SetReticleMaterialParamVector(class FName ParamName, const struct FVector& Value)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayAbilityWorldReticle", "SetReticleMaterialParamVector");
|
|
|
|
Params::GameplayAbilityWorldReticle_SetReticleMaterialParamVector Parms{};
|
|
|
|
Parms.ParamName = ParamName;
|
|
Parms.Value = std::move(Value);
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayModMagnitudeCalculation.CalculateBaseMagnitude
|
|
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// const struct FGameplayEffectSpec& Spec (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UGameplayModMagnitudeCalculation::CalculateBaseMagnitude(const struct FGameplayEffectSpec& Spec) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayModMagnitudeCalculation", "CalculateBaseMagnitude");
|
|
|
|
Params::GameplayModMagnitudeCalculation_CalculateBaseMagnitude Parms{};
|
|
|
|
Parms.Spec = std::move(Spec);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function GameplayAbilities.GameplayTagReponseTable.TagResponseEvent
|
|
// (Final, Native, Protected)
|
|
// Parameters:
|
|
// const struct FGameplayTag& Tag (ConstParm, Parm, NativeAccessSpecifierPublic)
|
|
// int32 NewCount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAbilitySystemComponent* ASC (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 Idx (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGameplayTagReponseTable::TagResponseEvent(const struct FGameplayTag& Tag, int32 NewCount, class UAbilitySystemComponent* ASC, int32 Idx)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GameplayTagReponseTable", "TagResponseEvent");
|
|
|
|
Params::GameplayTagReponseTable_TagResponseEvent Parms{};
|
|
|
|
Parms.Tag = std::move(Tag);
|
|
Parms.NewCount = NewCount;
|
|
Parms.ASC = ASC;
|
|
Parms.Idx = Idx;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
}
|
|
|
|
#pragma pack(pop)
|