#pragma once

/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/

// Package: AbstractCharacter

#include "Basic.hpp"

#include "AbstractCharacter_classes.hpp"
#include "AbstractCharacter_parameters.hpp"


namespace SDK
{

// Function AbstractCharacter.AbstractCharacter_C.ActiveRagdollEvent
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::ActiveRagdollEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ActiveRagdollEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.AddForceToPhysBodyWhenOverlaped
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference)

void AAbstractCharacter_C::AddForceToPhysBodyWhenOverlaped(const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "AddForceToPhysBodyWhenOverlaped");

	Params::AbstractCharacter_C_AddForceToPhysBodyWhenOverlaped Parms{};

	Parms.Hit = std::move(Hit);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.AddSpecialAccum
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              FirstEffect                                            (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// double                                  FirstParam                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::AddSpecialAccum(const struct FGameplayTag& FirstEffect, double FirstParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "AddSpecialAccum");

	Params::AbstractCharacter_C_AddSpecialAccum Parms{};

	Parms.FirstEffect = std::move(FirstEffect);
	Parms.FirstParam = FirstParam;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.AdjustEffectDuration
// (Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  NewDuration                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::AdjustEffectDuration(E_EffectType Type, double NewDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "AdjustEffectDuration");

	Params::AbstractCharacter_C_AdjustEffectDuration Parms{};

	Parms.Type = Type;
	Parms.NewDuration = NewDuration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.AnimationCallback
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    EventName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void AAbstractCharacter_C::AnimationCallback(const class FString& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "AnimationCallback");

	Params::AbstractCharacter_C_AnimationCallback Parms{};

	Parms.EventName = std::move(EventName);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.AnimationEvent
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             AnimationEvent_0                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::AnimationEvent(class FName AnimationEvent_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "AnimationEvent");

	Params::AbstractCharacter_C_AnimationEvent Parms{};

	Parms.AnimationEvent_0 = AnimationEvent_0;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Apply Effect
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Duration                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Applier                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_ApplyEffectMethod                     Method                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   Arg0                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   ImpactDirection                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Applied                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Apply_Effect(E_EffectType Type, double Duration, class AActor* Applier, E_ApplyEffectMethod Method, int32 Arg0, const struct FVector& ImpactDirection, bool* Applied)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Apply Effect");

	Params::AbstractCharacter_C_Apply_Effect Parms{};

	Parms.Type = Type;
	Parms.Duration = Duration;
	Parms.Applier = Applier;
	Parms.Method = Method;
	Parms.Arg0 = Arg0;
	Parms.ImpactDirection = std::move(ImpactDirection);

	UObject::ProcessEvent(Func, &Parms);

	if (Applied != nullptr)
		*Applied = Parms.Applied;
}


// Function AbstractCharacter.AbstractCharacter_C.ApplyedEffectToOtherCharacter
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            Effect                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AAbstractCharacter_C*             ApplyedCharacter                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ApplyedEffectToOtherCharacter(E_EffectType Effect, class AAbstractCharacter_C* ApplyedCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ApplyedEffectToOtherCharacter");

	Params::AbstractCharacter_C_ApplyedEffectToOtherCharacter Parms{};

	Parms.Effect = Effect;
	Parms.ApplyedCharacter = ApplyedCharacter;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ApplyForceActingEffectBack
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    Result                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ApplyFlyEffect                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ApplyForceActingEffectBack(class AAbstractCharacter_C* Attacker, bool Result, bool ApplyFlyEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ApplyForceActingEffectBack");

	Params::AbstractCharacter_C_ApplyForceActingEffectBack Parms{};

	Parms.Attacker = Attacker;
	Parms.Result = Result;
	Parms.ApplyFlyEffect = ApplyFlyEffect;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ApplySpecialDamageData
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const TMap<struct FGameplayTag, double>&PropsData                                              (BlueprintVisible, BlueprintReadOnly, Parm)
// class AActor*                           HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_AttackResult                          AttackResult                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ApplySpecialDamageData(const TMap<struct FGameplayTag, double>& PropsData, class AActor* HitTarget, E_AttackResult AttackResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ApplySpecialDamageData");

	Params::AbstractCharacter_C_ApplySpecialDamageData Parms{};

	Parms.PropsData = std::move(PropsData);
	Parms.HitTarget = HitTarget;
	Parms.AttackResult = AttackResult;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.BindEvents
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::BindEvents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "BindEvents");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_1_OnDissolveStart__DelegateSignature
// (BlueprintEvent)
// Parameters:
// class FName                             Key                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsDissolve                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_1_OnDissolveStart__DelegateSignature(class FName Key, bool IsDissolve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_1_OnDissolveStart__DelegateSignature");

	Params::AbstractCharacter_C_BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_1_OnDissolveStart__DelegateSignature Parms{};

	Parms.Key = Key;
	Parms.IsDissolve = IsDissolve;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_2_OnDissolveTick__DelegateSignature
// (BlueprintEvent)
// Parameters:
// class FName                             Key                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Value                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsDissolve                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             ParameterName                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_2_OnDissolveTick__DelegateSignature(class FName Key, double Value, bool IsDissolve, class FName ParameterName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_2_OnDissolveTick__DelegateSignature");

	Params::AbstractCharacter_C_BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_2_OnDissolveTick__DelegateSignature Parms{};

	Parms.Key = Key;
	Parms.Value = Value;
	Parms.IsDissolve = IsDissolve;
	Parms.ParameterName = ParameterName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_3_OnDissolveEnd__DelegateSignature
// (BlueprintEvent)
// Parameters:
// class FName                             Key                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsDissolve                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_3_OnDissolveEnd__DelegateSignature(class FName Key, bool IsDissolve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_3_OnDissolveEnd__DelegateSignature");

	Params::AbstractCharacter_C_BndEvt__AbstractCharacter_AC_DissolveComponent_K2Node_ComponentBoundEvent_3_OnDissolveEnd__DelegateSignature Parms{};

	Parms.Key = Key;
	Parms.IsDissolve = IsDissolve;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.BndEvt__AbstractCharacter_CapsuleComponent_K2Node_ComponentBoundEvent_0_ComponentBeginOverlapSignature__DelegateSignature
// (HasOutParams, BlueprintEvent)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class AActor*                           OtherActor                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UPrimitiveComponent*              OtherComp                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// int32                                   OtherBodyIndex                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    bFromSweep                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FHitResult&                SweepResult                                            (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference)

void AAbstractCharacter_C::BndEvt__AbstractCharacter_CapsuleComponent_K2Node_ComponentBoundEvent_0_ComponentBeginOverlapSignature__DelegateSignature(class UPrimitiveComponent* OverlappedComponent, 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("AbstractCharacter_C", "BndEvt__AbstractCharacter_CapsuleComponent_K2Node_ComponentBoundEvent_0_ComponentBeginOverlapSignature__DelegateSignature");

	Params::AbstractCharacter_C_BndEvt__AbstractCharacter_CapsuleComponent_K2Node_ComponentBoundEvent_0_ComponentBeginOverlapSignature__DelegateSignature Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.calculateWeaponBlockData
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 NewParam                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::calculateWeaponBlockData(double* NewParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "calculateWeaponBlockData");

	Params::AbstractCharacter_C_calculateWeaponBlockData Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (NewParam != nullptr)
		*NewParam = Parms.NewParam;
}


// Function AbstractCharacter.AbstractCharacter_C.Call_SponsorActingEffect
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AAbstractCharacter_C*             HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Call_SponsorActingEffect(int32 SkillID, class AAbstractCharacter_C* HitTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Call_SponsorActingEffect");

	Params::AbstractCharacter_C_Call_SponsorActingEffect Parms{};

	Parms.SkillID = SkillID;
	Parms.HitTarget = HitTarget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallAttackResult
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_AttackResult                          Result                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallAttackResult(E_AttackResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallAttackResult");

	Params::AbstractCharacter_C_CallAttackResult Parms{};

	Parms.Result = Result;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallBack_ApplyForceActingEffect
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            VectimEffectType                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   UsePairedAnimation                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     AnimationStarter                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class AAbstractCharacter_C*             Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ApplyFlyEffect                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallBack_ApplyForceActingEffect(E_EffectType VectimEffectType, int32 UsePairedAnimation, class UAnimMontage* AnimationStarter, class AAbstractCharacter_C* Attacker, bool ApplyFlyEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallBack_ApplyForceActingEffect");

	Params::AbstractCharacter_C_CallBack_ApplyForceActingEffect Parms{};

	Parms.VectimEffectType = VectimEffectType;
	Parms.UsePairedAnimation = UsePairedAnimation;
	Parms.AnimationStarter = AnimationStarter;
	Parms.Attacker = Attacker;
	Parms.ApplyFlyEffect = ApplyFlyEffect;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallBack_TakeDamage
// (HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FSS_TakeDamage&            NetworkDamageData                                      (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)

void AAbstractCharacter_C::CallBack_TakeDamage(class AActor* Attacker, const struct FSS_TakeDamage& NetworkDamageData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallBack_TakeDamage");

	Params::AbstractCharacter_C_CallBack_TakeDamage Parms{};

	Parms.Attacker = Attacker;
	Parms.NetworkDamageData = std::move(NetworkDamageData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallClient_ApplyForceActingEffect
// (Net, NetReliable, NetClient, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            VectimEffectType                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   UsePairedAnimation                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     AnimationStarter                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class AAbstractCharacter_C*             Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ApplyFlyEffect                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallClient_ApplyForceActingEffect(E_EffectType VectimEffectType, int32 UsePairedAnimation, class UAnimMontage* AnimationStarter, class AAbstractCharacter_C* Attacker, bool ApplyFlyEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallClient_ApplyForceActingEffect");

	Params::AbstractCharacter_C_CallClient_ApplyForceActingEffect Parms{};

	Parms.VectimEffectType = VectimEffectType;
	Parms.UsePairedAnimation = UsePairedAnimation;
	Parms.AnimationStarter = AnimationStarter;
	Parms.Attacker = Attacker;
	Parms.ApplyFlyEffect = ApplyFlyEffect;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallClient_ApplyForceActingEffectBack
// (Net, NetReliable, NetClient, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Result                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallClient_ApplyForceActingEffectBack(bool Result, class AActor* HitTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallClient_ApplyForceActingEffectBack");

	Params::AbstractCharacter_C_CallClient_ApplyForceActingEffectBack Parms{};

	Parms.Result = Result;
	Parms.HitTarget = HitTarget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallClient_BackDirectDamage
// (Net, NetReliable, HasOutParams, NetClient, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FSS_TakeDamage&            HitData                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)
// E_EffectType                            EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallClient_BackDirectDamage(const struct FSS_TakeDamage& HitData, E_EffectType EffectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallClient_BackDirectDamage");

	Params::AbstractCharacter_C_CallClient_BackDirectDamage Parms{};

	Parms.HitData = std::move(HitData);
	Parms.EffectType = EffectType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallClient_GetMeDirectDamage
// (Net, NetReliable, NetClient, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class FString&                    SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// E_EffectType                            EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallClient_GetMeDirectDamage(class AAbstractCharacter_C* HitTarget, const class FString& SkillID, E_EffectType EffectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallClient_GetMeDirectDamage");

	Params::AbstractCharacter_C_CallClient_GetMeDirectDamage Parms{};

	Parms.HitTarget = HitTarget;
	Parms.SkillID = std::move(SkillID);
	Parms.EffectType = EffectType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallClient_SponsorActingEffect
// (Net, NetReliable, NetClient, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AAbstractCharacter_C*             HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallClient_SponsorActingEffect(int32 SkillID, class AAbstractCharacter_C* HitTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallClient_SponsorActingEffect");

	Params::AbstractCharacter_C_CallClient_SponsorActingEffect Parms{};

	Parms.SkillID = SkillID;
	Parms.HitTarget = HitTarget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallClient_TakeDamage
// (Net, NetReliable, NetClient, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FSS_TakeDamage&            NetworkDamageData                                      (BlueprintVisible, BlueprintReadOnly, Parm, ContainsInstancedReference, HasGetValueTypeHash)

void AAbstractCharacter_C::CallClient_TakeDamage(class AActor* Attacker, const struct FSS_TakeDamage& NetworkDamageData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallClient_TakeDamage");

	Params::AbstractCharacter_C_CallClient_TakeDamage Parms{};

	Parms.Attacker = Attacker;
	Parms.NetworkDamageData = std::move(NetworkDamageData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallServer_ApplyForceActingEffect
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             HitCharacter                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_EffectType                            VectimEffectType                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   UsePairedAnimation                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     AnimationStarter                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ApplyFlyEffect                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallServer_ApplyForceActingEffect(class AAbstractCharacter_C* HitCharacter, E_EffectType VectimEffectType, int32 UsePairedAnimation, class UAnimMontage* AnimationStarter, bool ApplyFlyEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallServer_ApplyForceActingEffect");

	Params::AbstractCharacter_C_CallServer_ApplyForceActingEffect Parms{};

	Parms.HitCharacter = HitCharacter;
	Parms.VectimEffectType = VectimEffectType;
	Parms.UsePairedAnimation = UsePairedAnimation;
	Parms.AnimationStarter = AnimationStarter;
	Parms.ApplyFlyEffect = ApplyFlyEffect;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallServer_ApplyForceActingEffectBack
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    Result                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallServer_ApplyForceActingEffectBack(class AAbstractCharacter_C* Attacker, bool Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallServer_ApplyForceActingEffectBack");

	Params::AbstractCharacter_C_CallServer_ApplyForceActingEffectBack Parms{};

	Parms.Attacker = Attacker;
	Parms.Result = Result;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallServer_BackDirectDamage
// (Net, NetReliable, NetServer, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FSS_TakeDamage&            HitData                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)
// E_EffectType                            EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallServer_BackDirectDamage(class AAbstractCharacter_C* HitTarget, const struct FSS_TakeDamage& HitData, E_EffectType EffectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallServer_BackDirectDamage");

	Params::AbstractCharacter_C_CallServer_BackDirectDamage Parms{};

	Parms.HitTarget = HitTarget;
	Parms.HitData = std::move(HitData);
	Parms.EffectType = EffectType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallServer_GetMeDirectDamage
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class FString&                    SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// E_EffectType                            EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallServer_GetMeDirectDamage(class AAbstractCharacter_C* Attacker, const class FString& SkillID, E_EffectType EffectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallServer_GetMeDirectDamage");

	Params::AbstractCharacter_C_CallServer_GetMeDirectDamage Parms{};

	Parms.Attacker = Attacker;
	Parms.SkillID = std::move(SkillID);
	Parms.EffectType = EffectType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallServer_RecordHurtEnmey
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallServer_RecordHurtEnmey(class AAbstractCharacter_C* Attacker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallServer_RecordHurtEnmey");

	Params::AbstractCharacter_C_CallServer_RecordHurtEnmey Parms{};

	Parms.Attacker = Attacker;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallServer_SponsorActingEffectToApplier
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Applier                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallServer_SponsorActingEffectToApplier(int32 SkillID, class AActor* Applier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallServer_SponsorActingEffectToApplier");

	Params::AbstractCharacter_C_CallServer_SponsorActingEffectToApplier Parms{};

	Parms.SkillID = SkillID;
	Parms.Applier = Applier;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallServer_TakeDamage
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FSS_TakeDamage&            NetworkDamageData                                      (BlueprintVisible, BlueprintReadOnly, Parm, ContainsInstancedReference, HasGetValueTypeHash)

void AAbstractCharacter_C::CallServer_TakeDamage(class AActor* Attacker, const struct FSS_TakeDamage& NetworkDamageData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallServer_TakeDamage");

	Params::AbstractCharacter_C_CallServer_TakeDamage Parms{};

	Parms.Attacker = Attacker;
	Parms.NetworkDamageData = std::move(NetworkDamageData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallSync_AttackResult
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_AttackResult                          Result                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallSync_AttackResult(E_AttackResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallSync_AttackResult");

	Params::AbstractCharacter_C_CallSync_AttackResult Parms{};

	Parms.Result = Result;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallSync_CharacterDeath
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     MontageToPlay                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallSync_CharacterDeath(class UAnimMontage* MontageToPlay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallSync_CharacterDeath");

	Params::AbstractCharacter_C_CallSync_CharacterDeath Parms{};

	Parms.MontageToPlay = MontageToPlay;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallSync_DecayedImpactVelocity
// (Net, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector_NetQuantize100&    InMaxVelocity                                          (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// class UCurveFloat*                      InAlphaCurve                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const float                             InMaxDuration                                          (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallSync_DecayedImpactVelocity(const struct FVector_NetQuantize100& InMaxVelocity, class UCurveFloat* InAlphaCurve, const float InMaxDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallSync_DecayedImpactVelocity");

	Params::AbstractCharacter_C_CallSync_DecayedImpactVelocity Parms{};

	Parms.InMaxVelocity = std::move(InMaxVelocity);
	Parms.InAlphaCurve = InAlphaCurve;
	Parms.InMaxDuration = InMaxDuration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallSync_ForceActingPlay
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           TargetActor                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     MainMontageToPlay                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UAnimSequenceBase*                TargetMontageToPlay                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_PairedAnimMovingType                  PrepareMove                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    DelayedTargetExecuteMontage                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallSync_ForceActingPlay(class AActor* TargetActor, class UAnimMontage* MainMontageToPlay, class UAnimSequenceBase* TargetMontageToPlay, E_PairedAnimMovingType PrepareMove, bool DelayedTargetExecuteMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallSync_ForceActingPlay");

	Params::AbstractCharacter_C_CallSync_ForceActingPlay Parms{};

	Parms.TargetActor = TargetActor;
	Parms.MainMontageToPlay = MainMontageToPlay;
	Parms.TargetMontageToPlay = TargetMontageToPlay;
	Parms.PrepareMove = PrepareMove;
	Parms.DelayedTargetExecuteMontage = DelayedTargetExecuteMontage;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallSync_JumpToSection
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             SectionName                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallSync_JumpToSection(class FName SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallSync_JumpToSection");

	Params::AbstractCharacter_C_CallSync_JumpToSection Parms{};

	Parms.SectionName = SectionName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallSync_MontagePlay
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     MontageToPlay                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    JumpSection                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             SectionName                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallSync_MontagePlay(class UAnimMontage* MontageToPlay, bool JumpSection, class FName SectionName, E_MontageAction Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallSync_MontagePlay");

	Params::AbstractCharacter_C_CallSync_MontagePlay Parms{};

	Parms.MontageToPlay = MontageToPlay;
	Parms.JumpSection = JumpSection;
	Parms.SectionName = SectionName;
	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CallSync_ResetBS
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    BSKey                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    Immediately                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CallSync_ResetBS(const class FString& BSKey, bool Immediately)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CallSync_ResetBS");

	Params::AbstractCharacter_C_CallSync_ResetBS Parms{};

	Parms.BSKey = std::move(BSKey);
	Parms.Immediately = Immediately;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CalSync_SwitchBS
// (Net, NetReliable, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBlendSpace*                      NewBS                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class FString&                    BSKey                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    Immediately                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CalSync_SwitchBS(class UBlendSpace* NewBS, const class FString& BSKey, bool Immediately)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CalSync_SwitchBS");

	Params::AbstractCharacter_C_CalSync_SwitchBS Parms{};

	Parms.NewBS = NewBS;
	Parms.BSKey = std::move(BSKey);
	Parms.Immediately = Immediately;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Can  be Backstabbed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Can__be_Backstabbed(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Can  be Backstabbed");

	Params::AbstractCharacter_C_Can__be_Backstabbed Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.Can be Attacked
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Can_be_Attacked(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Can be Attacked");

	Params::AbstractCharacter_C_Can_be_Attacked Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.Can be Attacked Even Dying
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Can_be_Attacked_Even_Dying(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Can be Attacked Even Dying");

	Params::AbstractCharacter_C_Can_be_Attacked_Even_Dying Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.Can be Stunned
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Can_be_Stunned(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Can be Stunned");

	Params::AbstractCharacter_C_Can_be_Stunned Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.Can Flash Attack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Can_Flash_Attack(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Can Flash Attack");

	Params::AbstractCharacter_C_Can_Flash_Attack Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.CanEffectBeApplied
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Applier                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::CanEffectBeApplied(E_EffectType Type, class AActor* Applier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CanEffectBeApplied");

	Params::AbstractCharacter_C_CanEffectBeApplied Parms{};

	Parms.Type = Type;
	Parms.Applier = Applier;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.CanImpactAttackerIfBlockSuccess
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const struct FF_HitData&                F_HitData                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::CanImpactAttackerIfBlockSuccess(const struct FF_HitData& F_HitData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CanImpactAttackerIfBlockSuccess");

	Params::AbstractCharacter_C_CanImpactAttackerIfBlockSuccess Parms{};

	Parms.F_HitData = std::move(F_HitData);

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.ChangeHp
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Delta                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ChangeHp(double Delta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ChangeHp");

	Params::AbstractCharacter_C_ChangeHp Parms{};

	Parms.Delta = Delta;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Check Attacking Toughness
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    isPlayer                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   isAttacking                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Check_Attacking_Toughness(bool isPlayer, bool* isAttacking)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Check Attacking Toughness");

	Params::AbstractCharacter_C_Check_Attacking_Toughness Parms{};

	Parms.isPlayer = isPlayer;

	UObject::ProcessEvent(Func, &Parms);

	if (isAttacking != nullptr)
		*isAttacking = Parms.isAttacking;
}


// Function AbstractCharacter.AbstractCharacter_C.CheckDeathDissolve
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const float                             Value                                                  (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CheckDeathDissolve(const float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CheckDeathDissolve");

	Params::AbstractCharacter_C_CheckDeathDissolve Parms{};

	Parms.Value = Value;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.CheckPreRagdollOverlapingWhenTruthActive
// (Public, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::CheckPreRagdollOverlapingWhenTruthActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CheckPreRagdollOverlapingWhenTruthActive");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.CheckRagdollBodyConfig
// (Public, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::CheckRagdollBodyConfig()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CheckRagdollBodyConfig");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ChooseHitShakePlaying
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_ImpactType                            ImpactType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_EffectType                            EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_AttackResult                          HitResult                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   ImpactDirection                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           AttackerPlayer                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    PlayHitBreak_0                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    PlayShake                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ChooseHitShakePlaying(E_ImpactType ImpactType, E_EffectType EffectType, E_AttackResult HitResult, const struct FVector& ImpactDirection, class AActor* AttackerPlayer, bool PlayHitBreak_0, bool PlayShake)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ChooseHitShakePlaying");

	Params::AbstractCharacter_C_ChooseHitShakePlaying Parms{};

	Parms.ImpactType = ImpactType;
	Parms.EffectType = EffectType;
	Parms.HitResult = HitResult;
	Parms.ImpactDirection = std::move(ImpactDirection);
	Parms.AttackerPlayer = AttackerPlayer;
	Parms.PlayHitBreak_0 = PlayHitBreak_0;
	Parms.PlayShake = PlayShake;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ClearAllAction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   NewParam                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ClearAllAction(bool* NewParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ClearAllAction");

	Params::AbstractCharacter_C_ClearAllAction Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (NewParam != nullptr)
		*NewParam = Parms.NewParam;
}


// Function AbstractCharacter.AbstractCharacter_C.ClearAnimActor
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::ClearAnimActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ClearAnimActor");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.CloseCollisionWhenDeathLast
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::CloseCollisionWhenDeathLast()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CloseCollisionWhenDeathLast");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.CompositeHitData
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FST_HitDamageData&         HitMetaData                                            (BlueprintVisible, BlueprintReadOnly, Parm, HasGetValueTypeHash)
// class AActor*                           HitTargetActor                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FHitResult&                HitResultData                                          (BlueprintVisible, BlueprintReadOnly, Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference)
// struct FF_HitData*                      HitDataCompositedByAttacker                            (Parm, OutParm, ContainsInstancedReference, HasGetValueTypeHash)

void AAbstractCharacter_C::CompositeHitData(const struct FST_HitDamageData& HitMetaData, class AActor* HitTargetActor, const struct FHitResult& HitResultData, struct FF_HitData* HitDataCompositedByAttacker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CompositeHitData");

	Params::AbstractCharacter_C_CompositeHitData Parms{};

	Parms.HitMetaData = std::move(HitMetaData);
	Parms.HitTargetActor = HitTargetActor;
	Parms.HitResultData = std::move(HitResultData);

	UObject::ProcessEvent(Func, &Parms);

	if (HitDataCompositedByAttacker != nullptr)
		*HitDataCompositedByAttacker = std::move(Parms.HitDataCompositedByAttacker);
}


// Function AbstractCharacter.AbstractCharacter_C.CostStamina
// (Public, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::CostStamina()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CostStamina");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.CreateRagdollCheckBody
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FName                       BodyName                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::CreateRagdollCheckBody(const class FName BodyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "CreateRagdollCheckBody");

	Params::AbstractCharacter_C_CreateRagdollCheckBody Parms{};

	Parms.BodyName = BodyName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.death_1
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::death_1()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "death_1");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.death_2
// (Public, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::death_2()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "death_2");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.DelayDestroyAnimActor
// (HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   Duration                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class UClass*&                    ItemClass                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::DelayDestroyAnimActor(float Duration, const class UClass*& ItemClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "DelayDestroyAnimActor");

	Params::AbstractCharacter_C_DelayDestroyAnimActor Parms{};

	Parms.Duration = Duration;
	Parms.ItemClass = ItemClass;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.DestroyAnimActor
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UClass*&                    ItemClass                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::DestroyAnimActor(const class UClass*& ItemClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "DestroyAnimActor");

	Params::AbstractCharacter_C_DestroyAnimActor Parms{};

	Parms.ItemClass = ItemClass;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.DieEffect_Override
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     DeathMontage                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::DieEffect_Override(class UAnimMontage* DeathMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "DieEffect_Override");

	Params::AbstractCharacter_C_DieEffect_Override Parms{};

	Parms.DeathMontage = DeathMontage;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.EnableForceOnRagdoll
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   Duration                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::EnableForceOnRagdoll(float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "EnableForceOnRagdoll");

	Params::AbstractCharacter_C_EnableForceOnRagdoll Parms{};

	Parms.Duration = Duration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.EndDeathDissolve
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::EndDeathDissolve()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "EndDeathDissolve");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.EnterDeath
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   enter_death                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::EnterDeath(bool* enter_death)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "EnterDeath");

	Params::AbstractCharacter_C_EnterDeath Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (enter_death != nullptr)
		*enter_death = Parms.enter_death;
}


// Function AbstractCharacter.AbstractCharacter_C.ExecuteFXIsActive(Overloaded)
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::ExecuteFXIsActive_Overloaded_()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ExecuteFXIsActive(Overloaded)");

	Params::AbstractCharacter_C_ExecuteFXIsActive_Overloaded_ Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.ExecuteUbergraph_AbstractCharacter
// (Final, UbergraphFunction, HasDefaults)
// Parameters:
// int32                                   EntryPoint                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ExecuteUbergraph_AbstractCharacter(int32 EntryPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ExecuteUbergraph_AbstractCharacter");

	Params::AbstractCharacter_C_ExecuteUbergraph_AbstractCharacter Parms{};

	Parms.EntryPoint = EntryPoint;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.FreeAnimActor
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UClass*&                    ItemClass                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash)
// class AActor**                          ReturnFreeActor                                        (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::FreeAnimActor(const class UClass*& ItemClass, class AActor** ReturnFreeActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "FreeAnimActor");

	Params::AbstractCharacter_C_FreeAnimActor Parms{};

	Parms.ItemClass = ItemClass;

	UObject::ProcessEvent(Func, &Parms);

	if (ReturnFreeActor != nullptr)
		*ReturnFreeActor = Parms.ReturnFreeActor;
}


// Function AbstractCharacter.AbstractCharacter_C.Get Stunned Montage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_Direction                             FromDirection                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   stunLevel                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage**                    Montage                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UAnimSequence**                   Anim                                                   (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Get_Stunned_Montage(E_Direction FromDirection, int32 stunLevel, class UAnimMontage** Montage, class UAnimSequence** Anim)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Get Stunned Montage");

	Params::AbstractCharacter_C_Get_Stunned_Montage Parms{};

	Parms.FromDirection = FromDirection;
	Parms.stunLevel = stunLevel;

	UObject::ProcessEvent(Func, &Parms);

	if (Montage != nullptr)
		*Montage = Parms.Montage;

	if (Anim != nullptr)
		*Anim = Parms.Anim;
}


// Function AbstractCharacter.AbstractCharacter_C.GetAllAnimActor
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// TArray<class AActor*>*                  Values                                                 (Parm, OutParm)

void AAbstractCharacter_C::GetAllAnimActor(TArray<class AActor*>* Values)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetAllAnimActor");

	Params::AbstractCharacter_C_GetAllAnimActor Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Values != nullptr)
		*Values = std::move(Parms.Values);
}


// Function AbstractCharacter.AbstractCharacter_C.GetAnimItem
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             Name_0                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FST_AnimationViewer*             Item                                                   (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetAnimItem(class FName Name_0, struct FST_AnimationViewer* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetAnimItem");

	Params::AbstractCharacter_C_GetAnimItem Parms{};

	Parms.Name_0 = Name_0;

	UObject::ProcessEvent(Func, &Parms);

	if (Item != nullptr)
		*Item = std::move(Parms.Item);
}


// Function AbstractCharacter.AbstractCharacter_C.GetAnimProfile
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ForceUpdate                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UDataTable**                      Profile                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetAnimProfile(bool ForceUpdate, class UDataTable** Profile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetAnimProfile");

	Params::AbstractCharacter_C_GetAnimProfile Parms{};

	Parms.ForceUpdate = ForceUpdate;

	UObject::ProcessEvent(Func, &Parms);

	if (Profile != nullptr)
		*Profile = Parms.Profile;
}


// Function AbstractCharacter.AbstractCharacter_C.GetAttackSpCost
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// E_MeleeAttackType                       MeleeAttackType                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetAttackSpCost(E_MeleeAttackType MeleeAttackType, double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetAttackSpCost");

	Params::AbstractCharacter_C_GetAttackSpCost Parms{};

	Parms.MeleeAttackType = MeleeAttackType;

	UObject::ProcessEvent(Func, &Parms);

	if (Value != nullptr)
		*Value = Parms.Value;
}


// Function AbstractCharacter.AbstractCharacter_C.GetAttackSpeed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetAttackSpeed(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetAttackSpeed");

	Params::AbstractCharacter_C_GetAttackSpeed Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Value != nullptr)
		*Value = Parms.Value;
}


// Function AbstractCharacter.AbstractCharacter_C.GetBackAttackFactor
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double AAbstractCharacter_C::GetBackAttackFactor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetBackAttackFactor");

	Params::AbstractCharacter_C_GetBackAttackFactor Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetBindSocketNames
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class FName*                            executeTargetSocket                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName*                            executeCameraSocket                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetBindSocketNames(class FName* executeTargetSocket, class FName* executeCameraSocket)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetBindSocketNames");

	Params::AbstractCharacter_C_GetBindSocketNames Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (executeTargetSocket != nullptr)
		*executeTargetSocket = Parms.executeTargetSocket;

	if (executeCameraSocket != nullptr)
		*executeCameraSocket = Parms.executeCameraSocket;
}


// Function AbstractCharacter.AbstractCharacter_C.GetCharacterLODLevel
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// EDCSSlowTick                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

EDCSSlowTick AAbstractCharacter_C::GetCharacterLODLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetCharacterLODLevel");

	Params::AbstractCharacter_C_GetCharacterLODLevel Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetCollisionPart
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_CollisionPart                         L_CollisonPart1                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// TArray<struct FF_DamagePartParam>*      collisionParts                                         (Parm, OutParm, ContainsInstancedReference)

void AAbstractCharacter_C::GetCollisionPart(E_CollisionPart L_CollisonPart1, TArray<struct FF_DamagePartParam>* collisionParts)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetCollisionPart");

	Params::AbstractCharacter_C_GetCollisionPart Parms{};

	Parms.L_CollisonPart1 = L_CollisonPart1;

	UObject::ProcessEvent(Func, &Parms);

	if (collisionParts != nullptr)
		*collisionParts = std::move(Parms.collisionParts);
}


// Function AbstractCharacter.AbstractCharacter_C.GetCombatType
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// E_CombatType*                           CombatType                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetCombatType(E_CombatType* CombatType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetCombatType");

	Params::AbstractCharacter_C_GetCombatType Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (CombatType != nullptr)
		*CombatType = Parms.CombatType;
}


// Function AbstractCharacter.AbstractCharacter_C.GetDeathEffectCurve
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     DeathMontage                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UCurveFloat**                     Vanish                                                 (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetDeathEffectCurve(class UAnimMontage* DeathMontage, class UCurveFloat** Vanish)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetDeathEffectCurve");

	Params::AbstractCharacter_C_GetDeathEffectCurve Parms{};

	Parms.DeathMontage = DeathMontage;

	UObject::ProcessEvent(Func, &Parms);

	if (Vanish != nullptr)
		*Vanish = Parms.Vanish;
}


// Function AbstractCharacter.AbstractCharacter_C.GetDesiredFollowRotation
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FRotator*                        Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor)

void AAbstractCharacter_C::GetDesiredFollowRotation(struct FRotator* Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetDesiredFollowRotation");

	Params::AbstractCharacter_C_GetDesiredFollowRotation Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Rotation != nullptr)
		*Rotation = std::move(Parms.Rotation);
}


// Function AbstractCharacter.AbstractCharacter_C.GetDesiredRotation
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Refresh                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   rotateIntent                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FRotator*                        Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor)

void AAbstractCharacter_C::GetDesiredRotation(bool Refresh, int32 rotateIntent, struct FRotator* Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetDesiredRotation");

	Params::AbstractCharacter_C_GetDesiredRotation Parms{};

	Parms.Refresh = Refresh;
	Parms.rotateIntent = rotateIntent;

	UObject::ProcessEvent(Func, &Parms);

	if (Rotation != nullptr)
		*Rotation = std::move(Parms.Rotation);
}


// Function AbstractCharacter.AbstractCharacter_C.GetEffectMontageBlendInTime
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double AAbstractCharacter_C::GetEffectMontageBlendInTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetEffectMontageBlendInTime");

	Params::AbstractCharacter_C_GetEffectMontageBlendInTime Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetEffectMontageStartTime
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double AAbstractCharacter_C::GetEffectMontageStartTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetEffectMontageStartTime");

	Params::AbstractCharacter_C_GetEffectMontageStartTime Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetHp
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetHp(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetHp");

	Params::AbstractCharacter_C_GetHp Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Value != nullptr)
		*Value = Parms.Value;
}


// Function AbstractCharacter.AbstractCharacter_C.GetHp_Uniform
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetHp_Uniform(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetHp_Uniform");

	Params::AbstractCharacter_C_GetHp_Uniform Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Value != nullptr)
		*Value = Parms.Value;
}


// Function AbstractCharacter.AbstractCharacter_C.GetIsFullyOpenSimulatePhysics
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::GetIsFullyOpenSimulatePhysics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetIsFullyOpenSimulatePhysics");

	Params::AbstractCharacter_C_GetIsFullyOpenSimulatePhysics Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.getLadderPosition
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Position                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::getLadderPosition(double* Position)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "getLadderPosition");

	Params::AbstractCharacter_C_getLadderPosition Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Position != nullptr)
		*Position = Parms.Position;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMaxHp
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetMaxHp(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMaxHp");

	Params::AbstractCharacter_C_GetMaxHp Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Value != nullptr)
		*Value = Parms.Value;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMaxHp_Uniform
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetMaxHp_Uniform(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMaxHp_Uniform");

	Params::AbstractCharacter_C_GetMaxHp_Uniform Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Value != nullptr)
		*Value = Parms.Value;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMeDirectDamage
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// class AAbstractCharacter_C*             HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class FString&                    SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// E_EffectType                            EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetMeDirectDamage(class AAbstractCharacter_C* HitTarget, const class FString& SkillID, E_EffectType EffectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMeDirectDamage");

	Params::AbstractCharacter_C_GetMeDirectDamage Parms{};

	Parms.HitTarget = HitTarget;
	Parms.SkillID = std::move(SkillID);
	Parms.EffectType = EffectType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.GetMontages
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_MontageAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UDataTable**                      Montages                                               (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetMontages(E_MontageAction Action, class UDataTable** Montages)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMontages");

	Params::AbstractCharacter_C_GetMontages Parms{};

	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);

	if (Montages != nullptr)
		*Montages = Parms.Montages;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMontageSectionForAction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_MontageAction                         LocalAction                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     LocalMontage                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// int32                                   Index_0                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 OverrideBlendInTime                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

class FName AAbstractCharacter_C::GetMontageSectionForAction(E_MontageAction LocalAction, class UAnimMontage* LocalMontage, int32 Index_0, double* OverrideBlendInTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMontageSectionForAction");

	Params::AbstractCharacter_C_GetMontageSectionForAction Parms{};

	Parms.LocalAction = LocalAction;
	Parms.LocalMontage = LocalMontage;
	Parms.Index_0 = Index_0;

	UObject::ProcessEvent(Func, &Parms);

	if (OverrideBlendInTime != nullptr)
		*OverrideBlendInTime = Parms.OverrideBlendInTime;

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMyCharacterShound
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UCharacterSoundComponent_C**      CharacterSoundComponent                                (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetMyCharacterShound(class UCharacterSoundComponent_C** CharacterSoundComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMyCharacterShound");

	Params::AbstractCharacter_C_GetMyCharacterShound Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (CharacterSoundComponent != nullptr)
		*CharacterSoundComponent = Parms.CharacterSoundComponent;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMyDissolve
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UAC_DissolveComponent_C**         DissolveComp                                           (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetMyDissolve(class UAC_DissolveComponent_C** DissolveComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMyDissolve");

	Params::AbstractCharacter_C_GetMyDissolve Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (DissolveComp != nullptr)
		*DissolveComp = Parms.DissolveComp;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMyForceActing
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UForceActingComponent_C*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash)

class UForceActingComponent_C* AAbstractCharacter_C::GetMyForceActing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMyForceActing");

	Params::AbstractCharacter_C_GetMyForceActing Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMyStatBar
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UWidgetComponent*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash)

class UWidgetComponent* AAbstractCharacter_C::GetMyStatBar()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMyStatBar");

	Params::AbstractCharacter_C_GetMyStatBar Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetMyTargetBillboardRootComponent
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash)

class USceneComponent* AAbstractCharacter_C::GetMyTargetBillboardRootComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetMyTargetBillboardRootComponent");

	Params::AbstractCharacter_C_GetMyTargetBillboardRootComponent Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetNetworkState
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class ADCS_SyncState_C*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash)

class ADCS_SyncState_C* AAbstractCharacter_C::GetNetworkState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetNetworkState");

	Params::AbstractCharacter_C_GetNetworkState Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetRealBlockingState
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::GetRealBlockingState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetRealBlockingState");

	Params::AbstractCharacter_C_GetRealBlockingState Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetReduceDamage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AActor*                           DamageCauser                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double AAbstractCharacter_C::GetReduceDamage(class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetReduceDamage");

	Params::AbstractCharacter_C_GetReduceDamage Parms{};

	Parms.DamageCauser = DamageCauser;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.GetSelectedWeaponDisplayItem
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class ADisplayedItem_C**                DisplayedItem                                          (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetSelectedWeaponDisplayItem(class ADisplayedItem_C** DisplayedItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetSelectedWeaponDisplayItem");

	Params::AbstractCharacter_C_GetSelectedWeaponDisplayItem Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (DisplayedItem != nullptr)
		*DisplayedItem = Parms.DisplayedItem;
}


// Function AbstractCharacter.AbstractCharacter_C.GetSelectedWeaponType
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// E_ItemType*                             Type                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetSelectedWeaponType(E_ItemType* Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetSelectedWeaponType");

	Params::AbstractCharacter_C_GetSelectedWeaponType Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Type != nullptr)
		*Type = Parms.Type;
}


// Function AbstractCharacter.AbstractCharacter_C.GetState
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// E_State*                                State                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetState(E_State* State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetState");

	Params::AbstractCharacter_C_GetState Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (State != nullptr)
		*State = Parms.State;
}


// Function AbstractCharacter.AbstractCharacter_C.GetStatsValue
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const struct FGameplayTag&              Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::GetStatsValue(const struct FGameplayTag& Type, double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "GetStatsValue");

	Params::AbstractCharacter_C_GetStatsValue Parms{};

	Parms.Type = std::move(Type);

	UObject::ProcessEvent(Func, &Parms);

	if (Value != nullptr)
		*Value = Parms.Value;
}


// Function AbstractCharacter.AbstractCharacter_C.ImplBreakPoint
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    StateName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    EventName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::ImplBreakPoint(const class FString& StateName, const class FString& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplBreakPoint");

	Params::AbstractCharacter_C_ImplBreakPoint Parms{};

	Parms.StateName = std::move(StateName);
	Parms.EventName = std::move(EventName);

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.ImplBufferInput
// (Event, Public, BlueprintEvent)
// Parameters:
// const uint8                             InAction                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ImplBufferInput(const uint8 InAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplBufferInput");

	Params::AbstractCharacter_C_ImplBufferInput Parms{};

	Parms.InAction = InAction;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplDeath1
// (Event, Public, BlueprintEvent)

void AAbstractCharacter_C::ImplDeath1()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplDeath1");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplFallendamageBufferInput
// (Event, Public, BlueprintEvent)
// Parameters:
// const uint8                             InAction                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ImplFallendamageBufferInput(const uint8 InAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplFallendamageBufferInput");

	Params::AbstractCharacter_C_ImplFallendamageBufferInput Parms{};

	Parms.InAction = InAction;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplHoldActioninput
// (Event, Public, BlueprintEvent)
// Parameters:
// const uint8                             InAction                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ImplHoldActioninput(const uint8 InAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplHoldActioninput");

	Params::AbstractCharacter_C_ImplHoldActioninput Parms{};

	Parms.InAction = InAction;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplInputInteract
// (Event, Public, BlueprintEvent)

void AAbstractCharacter_C::ImplInputInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplInputInteract");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplPrintPoint
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    StateName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    EventName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::ImplPrintPoint(const class FString& StateName, const class FString& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplPrintPoint");

	Params::AbstractCharacter_C_ImplPrintPoint Parms{};

	Parms.StateName = std::move(StateName);
	Parms.EventName = std::move(EventName);

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.ImplSetState
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    InStateType                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::ImplSetState(const class FString& InStateType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplSetState");

	Params::AbstractCharacter_C_ImplSetState Parms{};

	Parms.InStateType = std::move(InStateType);

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.ImplTakeDamage
// (Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGenericStructPasser&      InDamage                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// const struct FGenericStructPasser&      InHitresult                                            (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// bool*                                   OutHandled                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// uint8*                                  OutReturnresult                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ImplTakeDamage(const struct FGenericStructPasser& InDamage, const struct FGenericStructPasser& InHitresult, bool* OutHandled, uint8* OutReturnresult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplTakeDamage");

	Params::AbstractCharacter_C_ImplTakeDamage Parms{};

	Parms.InDamage = std::move(InDamage);
	Parms.InHitresult = std::move(InHitresult);

	UObject::ProcessEvent(Func, &Parms);

	if (OutHandled != nullptr)
		*OutHandled = Parms.OutHandled;

	if (OutReturnresult != nullptr)
		*OutReturnresult = Parms.OutReturnresult;
}


// Function AbstractCharacter.AbstractCharacter_C.ImplTakeDirectDamage
// (Event, Public, BlueprintEvent)
// Parameters:
// const float                             InValue                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           InCauser                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ImplTakeDirectDamage(const float InValue, class AActor* InCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplTakeDirectDamage");

	Params::AbstractCharacter_C_ImplTakeDirectDamage Parms{};

	Parms.InValue = InValue;
	Parms.InCauser = InCauser;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplTickMove
// (Event, Public, BlueprintEvent)

void AAbstractCharacter_C::ImplTickMove()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplTickMove");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplTryBreakInteract
// (Event, Public, BlueprintEvent)

void AAbstractCharacter_C::ImplTryBreakInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplTryBreakInteract");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplTryEndRebornfire
// (Event, Public, BlueprintEvent)

void AAbstractCharacter_C::ImplTryEndRebornfire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplTryEndRebornfire");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplUpdateForwardmove
// (Event, Public, BlueprintEvent)

void AAbstractCharacter_C::ImplUpdateForwardmove()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplUpdateForwardmove");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplWeaponLoopBufferInput
// (Event, Public, BlueprintEvent)
// Parameters:
// const uint8                             InAction                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ImplWeaponLoopBufferInput(const uint8 InAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplWeaponLoopBufferInput");

	Params::AbstractCharacter_C_ImplWeaponLoopBufferInput Parms{};

	Parms.InAction = InAction;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ImplWeaponLoopInputWithCheck
// (Event, Public, BlueprintEvent)
// Parameters:
// const uint8                             InAction                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ImplWeaponLoopInputWithCheck(const uint8 InAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ImplWeaponLoopInputWithCheck");

	Params::AbstractCharacter_C_ImplWeaponLoopInputWithCheck Parms{};

	Parms.InAction = InAction;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Init State Machine
// (Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UClass*                           StateMgrClass                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Init_State_Machine(class UClass* StateMgrClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Init State Machine");

	Params::AbstractCharacter_C_Init_State_Machine Parms{};

	Parms.StateMgrClass = StateMgrClass;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.InternalMontageAction
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_State                                 NewState                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     SelectedMontage                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  PlayRate                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             PresetSection                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    StopAllMontags                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FGameplayTag&              PlayerAction                                           (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// float                                   BlendInTimeOverride                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   InTimeToStartMontageAt                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 DurationToEnd                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Success                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::InternalMontageAction(E_State NewState, E_MontageAction Action, class UAnimMontage* SelectedMontage, double PlayRate, class FName PresetSection, bool StopAllMontags, const struct FGameplayTag& PlayerAction, float BlendInTimeOverride, float InTimeToStartMontageAt, double* DurationToEnd, bool* Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "InternalMontageAction");

	Params::AbstractCharacter_C_InternalMontageAction Parms{};

	Parms.NewState = NewState;
	Parms.Action = Action;
	Parms.SelectedMontage = SelectedMontage;
	Parms.PlayRate = PlayRate;
	Parms.PresetSection = PresetSection;
	Parms.StopAllMontags = StopAllMontags;
	Parms.PlayerAction = std::move(PlayerAction);
	Parms.BlendInTimeOverride = BlendInTimeOverride;
	Parms.InTimeToStartMontageAt = InTimeToStartMontageAt;

	UObject::ProcessEvent(Func, &Parms);

	if (DurationToEnd != nullptr)
		*DurationToEnd = Parms.DurationToEnd;

	if (Success != nullptr)
		*Success = Parms.Success;
}


// Function AbstractCharacter.AbstractCharacter_C.IsAlive
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::IsAlive(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "IsAlive");

	Params::AbstractCharacter_C_IsAlive Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.IsAttackableTarget
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Target                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::IsAttackableTarget(class AActor* Target, bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "IsAttackableTarget");

	Params::AbstractCharacter_C_IsAttackableTarget Parms{};

	Parms.Target = Target;

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.IsInCombatPose
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::IsInCombatPose(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "IsInCombatPose");

	Params::AbstractCharacter_C_IsInCombatPose Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.IsShieldEquipped
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::IsShieldEquipped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "IsShieldEquipped");

	Params::AbstractCharacter_C_IsShieldEquipped Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.JumpToSection
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             SectionName                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::JumpToSection(class FName SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "JumpToSection");

	Params::AbstractCharacter_C_JumpToSection Parms{};

	Parms.SectionName = SectionName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.MontageAction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_State                                 NewState                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   Index_0                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  PlayRate                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    StopAllMontages                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FGameplayTag&              PlayerAction                                           (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// double*                                 Duration                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::MontageAction(E_State NewState, E_MontageAction Action, int32 Index_0, double PlayRate, bool StopAllMontages, const struct FGameplayTag& PlayerAction, double* Duration, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "MontageAction");

	Params::AbstractCharacter_C_MontageAction Parms{};

	Parms.NewState = NewState;
	Parms.Action = Action;
	Parms.Index_0 = Index_0;
	Parms.PlayRate = PlayRate;
	Parms.StopAllMontages = StopAllMontages;
	Parms.PlayerAction = std::move(PlayerAction);

	UObject::ProcessEvent(Func, &Parms);

	if (Duration != nullptr)
		*Duration = Parms.Duration;

	if (Succeed != nullptr)
		*Succeed = Parms.Succeed;
}


// Function AbstractCharacter.AbstractCharacter_C.OnActivityChanged_StateManagerComp
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_Activity                              Activity                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Value                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::OnActivityChanged_StateManagerComp(E_Activity Activity, bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "OnActivityChanged_StateManagerComp");

	Params::AbstractCharacter_C_OnActivityChanged_StateManagerComp Parms{};

	Parms.Activity = Activity;
	Parms.Value = Value;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.OnApplyNewEffectEvent
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FF_Effect&                 EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::OnApplyNewEffectEvent(const struct FF_Effect& EffectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "OnApplyNewEffectEvent");

	Params::AbstractCharacter_C_OnApplyNewEffectEvent Parms{};

	Parms.EffectType = std::move(EffectType);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.OnBeginPlayDeathMontageEvent
// (Public, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::OnBeginPlayDeathMontageEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "OnBeginPlayDeathMontageEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.OnRagdollBodyOverlappedEvent
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class AActor*                           OtherActor                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UPrimitiveComponent*              OtherComp                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// int32                                   OtherBodyIndex                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    bFromSweep                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FHitResult&                SweepResult                                            (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference)

void AAbstractCharacter_C::OnRagdollBodyOverlappedEvent(class UPrimitiveComponent* OverlappedComponent, 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("AbstractCharacter_C", "OnRagdollBodyOverlappedEvent");

	Params::AbstractCharacter_C_OnRagdollBodyOverlappedEvent Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.OnValueChanged_Health
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// double                                  OldValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  MaxValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::OnValueChanged_Health(const struct FGameplayTag& Type, double OldValue, double NewValue, double MaxValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "OnValueChanged_Health");

	Params::AbstractCharacter_C_OnValueChanged_Health Parms{};

	Parms.Type = std::move(Type);
	Parms.OldValue = OldValue;
	Parms.NewValue = NewValue;
	Parms.MaxValue = MaxValue;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.OnValueChanged_HealthA
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// double                                  OldValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  MaxValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::OnValueChanged_HealthA(const struct FGameplayTag& Type, double OldValue, double NewValue, double MaxValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "OnValueChanged_HealthA");

	Params::AbstractCharacter_C_OnValueChanged_HealthA Parms{};

	Parms.Type = std::move(Type);
	Parms.OldValue = OldValue;
	Parms.NewValue = NewValue;
	Parms.MaxValue = MaxValue;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.OverrideTraceDamage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const int32                             TraceId                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const TArray<class AActor*>&            IgnoreActors                                           (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// TArray<struct FHitResult>*              OutHits                                                (Parm, OutParm, ContainsInstancedReference)

void AAbstractCharacter_C::OverrideTraceDamage(const int32 TraceId, const TArray<class AActor*>& IgnoreActors, TArray<struct FHitResult>* OutHits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "OverrideTraceDamage");

	Params::AbstractCharacter_C_OverrideTraceDamage Parms{};

	Parms.TraceId = TraceId;
	Parms.IgnoreActors = std::move(IgnoreActors);

	UObject::ProcessEvent(Func, &Parms);

	if (OutHits != nullptr)
		*OutHits = std::move(Parms.OutHits);
}


// Function AbstractCharacter.AbstractCharacter_C.Play Counter Attack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Play_Counter_Attack(bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Play Counter Attack");

	Params::AbstractCharacter_C_Play_Counter_Attack Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (Succeed != nullptr)
		*Succeed = Parms.Succeed;
}


// Function AbstractCharacter.AbstractCharacter_C.Play Flash
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    direct_flash                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Play_Flash(bool direct_flash, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Play Flash");

	Params::AbstractCharacter_C_Play_Flash Parms{};

	Parms.direct_flash = direct_flash;

	UObject::ProcessEvent(Func, &Parms);

	if (Succeed != nullptr)
		*Succeed = Parms.Succeed;
}


// Function AbstractCharacter.AbstractCharacter_C.Play FlashParry
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Index_0                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Play_FlashParry(int32 Index_0, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Play FlashParry");

	Params::AbstractCharacter_C_Play_FlashParry Parms{};

	Parms.Index_0 = Index_0;

	UObject::ProcessEvent(Func, &Parms);

	if (Succeed != nullptr)
		*Succeed = Parms.Succeed;
}


// Function AbstractCharacter.AbstractCharacter_C.PlayCameraShake
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// TSubclassOf<class UCameraShakeBase>     camerashake                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash)
// float                                   Scale                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PlayCameraShake(TSubclassOf<class UCameraShakeBase> camerashake, float Scale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PlayCameraShake");

	Params::AbstractCharacter_C_PlayCameraShake Parms{};

	Parms.camerashake = camerashake;
	Parms.Scale = Scale;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.PlayCharacterMontage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     MontageToPlay                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  InPlayRate                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    bStopAllMontages                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             LinkedTag                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             Section                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    SyncMontage                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Duration                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PlayCharacterMontage(class UAnimMontage* MontageToPlay, double InPlayRate, bool bStopAllMontages, class FName LinkedTag, class FName Section, bool SyncMontage, double* Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PlayCharacterMontage");

	Params::AbstractCharacter_C_PlayCharacterMontage Parms{};

	Parms.MontageToPlay = MontageToPlay;
	Parms.InPlayRate = InPlayRate;
	Parms.bStopAllMontages = bStopAllMontages;
	Parms.LinkedTag = LinkedTag;
	Parms.Section = Section;
	Parms.SyncMontage = SyncMontage;

	UObject::ProcessEvent(Func, &Parms);

	if (Duration != nullptr)
		*Duration = Parms.Duration;
}


// Function AbstractCharacter.AbstractCharacter_C.PlayEffectMongtage
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            Effect_Type                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         Montage_Action                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   ExtendArg                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   Impact_Direction                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PlayEffectMongtage(E_EffectType Effect_Type, E_MontageAction Montage_Action, int32 ExtendArg, const struct FVector& Impact_Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PlayEffectMongtage");

	Params::AbstractCharacter_C_PlayEffectMongtage Parms{};

	Parms.Effect_Type = Effect_Type;
	Parms.Montage_Action = Montage_Action;
	Parms.ExtendArg = ExtendArg;
	Parms.Impact_Direction = std::move(Impact_Direction);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.PlayFeedback
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UForceFeedbackEffect*             Feedback                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// float                                   Scale                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PlayFeedback(class UForceFeedbackEffect* Feedback, float Scale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PlayFeedback");

	Params::AbstractCharacter_C_PlayFeedback Parms{};

	Parms.Feedback = Feedback;
	Parms.Scale = Scale;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.PlayHitBreak
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           AttackerPlayer                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FST_HitShakeData&          Shake                                                  (BlueprintVisible, BlueprintReadOnly, Parm, HasGetValueTypeHash)
// const struct FVector&                   InMaxVelocity                                          (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PlayHitBreak(class AActor* AttackerPlayer, const struct FST_HitShakeData& Shake, const struct FVector& InMaxVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PlayHitBreak");

	Params::AbstractCharacter_C_PlayHitBreak Parms{};

	Parms.AttackerPlayer = AttackerPlayer;
	Parms.Shake = std::move(Shake);
	Parms.InMaxVelocity = std::move(InMaxVelocity);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.PlayHitShake
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FST_HitShakeData&          Shake                                                  (BlueprintVisible, BlueprintReadOnly, Parm, HasGetValueTypeHash)
// const struct FVector&                   HitForwardVector                                       (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const E_AttackResult                    HitResult                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           AttackerPlayer                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    PlayHitBreak_0                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    PlayShake                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PlayHitShake(const struct FST_HitShakeData& Shake, const struct FVector& HitForwardVector, const E_AttackResult HitResult, class AActor* AttackerPlayer, bool PlayHitBreak_0, bool PlayShake)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PlayHitShake");

	Params::AbstractCharacter_C_PlayHitShake Parms{};

	Parms.Shake = std::move(Shake);
	Parms.HitForwardVector = std::move(HitForwardVector);
	Parms.HitResult = HitResult;
	Parms.AttackerPlayer = AttackerPlayer;
	Parms.PlayHitBreak_0 = PlayHitBreak_0;
	Parms.PlayShake = PlayShake;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.PostHitTarget
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FHitResult&                HitResult                                              (BlueprintVisible, BlueprintReadOnly, Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference)
// E_AttackResult                          DamageResult                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    HasAppliedDamage                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Undelayed                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PostHitTarget(const struct FHitResult& HitResult, E_AttackResult DamageResult, bool HasAppliedDamage, bool Undelayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PostHitTarget");

	Params::AbstractCharacter_C_PostHitTarget Parms{};

	Parms.HitResult = std::move(HitResult);
	Parms.DamageResult = DamageResult;
	Parms.HasAppliedDamage = HasAppliedDamage;
	Parms.Undelayed = Undelayed;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.PreActiveRagdollEvent
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::PreActiveRagdollEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PreActiveRagdollEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.PresetDeathAnim
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     PresetDeathMontage_0                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UAnimSequence*                    PresetDeathAnimation_0                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::PresetDeathAnim(class UAnimMontage* PresetDeathMontage_0, class UAnimSequence* PresetDeathAnimation_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "PresetDeathAnim");

	Params::AbstractCharacter_C_PresetDeathAnim Parms{};

	Parms.PresetDeathMontage_0 = PresetDeathMontage_0;
	Parms.PresetDeathAnimation_0 = PresetDeathAnimation_0;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Private_TakeDamage
// (Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FF_HitData&                      EnemyHitData                                           (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)
// const struct FHitResult&                HitResult                                              (BlueprintVisible, BlueprintReadOnly, Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference)
// E_AttackResult*                         ResultType                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Private_TakeDamage(struct FF_HitData& EnemyHitData, const struct FHitResult& HitResult, E_AttackResult* ResultType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Private_TakeDamage");

	Params::AbstractCharacter_C_Private_TakeDamage Parms{};

	Parms.EnemyHitData = std::move(EnemyHitData);
	Parms.HitResult = std::move(HitResult);

	UObject::ProcessEvent(Func, &Parms);

	EnemyHitData = std::move(Parms.EnemyHitData);

	if (ResultType != nullptr)
		*ResultType = Parms.ResultType;
}


// Function AbstractCharacter.AbstractCharacter_C.Private_TakeDirectDamage
// (Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Value                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           DecreaseCauser                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Private_TakeDirectDamage(double Value, class AActor* DecreaseCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Private_TakeDirectDamage");

	Params::AbstractCharacter_C_Private_TakeDirectDamage Parms{};

	Parms.Value = Value;
	Parms.DecreaseCauser = DecreaseCauser;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Process_DamageResult
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              DamageResultType                                       (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// double                                  Value                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Causer                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Process_DamageResult(const struct FGameplayTag& DamageResultType, double Value, class AActor* Causer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Process_DamageResult");

	Params::AbstractCharacter_C_Process_DamageResult Parms{};

	Parms.DamageResultType = std::move(DamageResultType);
	Parms.Value = Value;
	Parms.Causer = Causer;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ProductAction
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Value                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_AIQueryAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ProductAction(int32 Value, E_AIQueryAction Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ProductAction");

	Params::AbstractCharacter_C_ProductAction Parms{};

	Parms.Value = Value;
	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.QueryAction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_AIQueryAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32*                                  Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::QueryAction(E_AIQueryAction Action, int32* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "QueryAction");

	Params::AbstractCharacter_C_QueryAction Parms{};

	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.QueryAndCosumeAction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Requester                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_AIQueryAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32*                                  Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::QueryAndCosumeAction(class AActor* Requester, E_AIQueryAction Action, int32* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "QueryAndCosumeAction");

	Params::AbstractCharacter_C_QueryAndCosumeAction Parms{};

	Parms.Requester = Requester;
	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);

	if (Result != nullptr)
		*Result = Parms.Result;
}


// Function AbstractCharacter.AbstractCharacter_C.ReceiveBeginPlay
// (Event, Protected, BlueprintEvent)

void AAbstractCharacter_C::ReceiveBeginPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ReceiveBeginPlay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.ReceiveDestroyed
// (Event, Public, BlueprintEvent)

void AAbstractCharacter_C::ReceiveDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ReceiveDestroyed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.recordAction
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_AIQueryAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::recordAction(E_AIQueryAction Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "recordAction");

	Params::AbstractCharacter_C_recordAction Parms{};

	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ReplaceBeginPlays
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::ReplaceBeginPlays()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ReplaceBeginPlays");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.Request_GetMeDirectDamage
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class FString&                    SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// E_EffectType                            EffectType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Request_GetMeDirectDamage(class AActor* Attacker, const class FString& SkillID, E_EffectType EffectType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Request_GetMeDirectDamage");

	Params::AbstractCharacter_C_Request_GetMeDirectDamage Parms{};

	Parms.Attacker = Attacker;
	Parms.SkillID = std::move(SkillID);
	Parms.EffectType = EffectType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.RequestAllActions
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<E_AIQueryAction>*                actions                                                (Parm, OutParm)

void AAbstractCharacter_C::RequestAllActions(TArray<E_AIQueryAction>* actions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "RequestAllActions");

	Params::AbstractCharacter_C_RequestAllActions Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (actions != nullptr)
		*actions = std::move(Parms.actions);
}


// Function AbstractCharacter.AbstractCharacter_C.ResetIdleState
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Delay                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ResetIdleState(double Delay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ResetIdleState");

	Params::AbstractCharacter_C_ResetIdleState Parms{};

	Parms.Delay = Delay;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ResetMeleeAttackCounter
// (Public, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::ResetMeleeAttackCounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ResetMeleeAttackCounter");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.Select Dead Montage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Random                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage**                    Montage                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Select_Dead_Montage(bool Random, class UAnimMontage** Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Select Dead Montage");

	Params::AbstractCharacter_C_Select_Dead_Montage Parms{};

	Parms.Random = Random;

	UObject::ProcessEvent(Func, &Parms);

	if (Montage != nullptr)
		*Montage = Parms.Montage;
}


// Function AbstractCharacter.AbstractCharacter_C.SelectAttackMontage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_MeleeAttackType                       MeleeAttackType                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ForceRsetCombo                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction*                        Action                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32*                                  Index_0                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SelectAttackMontage(E_MeleeAttackType MeleeAttackType, bool ForceRsetCombo, E_MontageAction* Action, int32* Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SelectAttackMontage");

	Params::AbstractCharacter_C_SelectAttackMontage Parms{};

	Parms.MeleeAttackType = MeleeAttackType;
	Parms.ForceRsetCombo = ForceRsetCombo;

	UObject::ProcessEvent(Func, &Parms);

	if (Action != nullptr)
		*Action = Parms.Action;

	if (Index_0 != nullptr)
		*Index_0 = Parms.Index_0;
}


// Function AbstractCharacter.AbstractCharacter_C.SetAttackCounterAccelerate
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetAttackCounterAccelerate(double NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetAttackCounterAccelerate");

	Params::AbstractCharacter_C_SetAttackCounterAccelerate Parms{};

	Parms.NewValue = NewValue;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetCanExecuteFXEnable(Overloaded)
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Enable                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetCanExecuteFXEnable_Overloaded_(bool Enable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetCanExecuteFXEnable(Overloaded)");

	Params::AbstractCharacter_C_SetCanExecuteFXEnable_Overloaded_ Parms{};

	Parms.Enable = Enable;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetCollisionWhenFullyOpenSimulatePhysics
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::SetCollisionWhenFullyOpenSimulatePhysics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetCollisionWhenFullyOpenSimulatePhysics");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.SetEnableRotateLookAt
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Enable                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    RotateWaist                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Target                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  Offset                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetEnableRotateLookAt(bool Enable, bool RotateWaist, class AActor* Target, double Offset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetEnableRotateLookAt");

	Params::AbstractCharacter_C_SetEnableRotateLookAt Parms{};

	Parms.Enable = Enable;
	Parms.RotateWaist = RotateWaist;
	Parms.Target = Target;
	Parms.Offset = Offset;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetEnableSlideRotate
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Enable                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   NewParam1                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetEnableSlideRotate(bool Enable, bool* NewParam1)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetEnableSlideRotate");

	Params::AbstractCharacter_C_SetEnableSlideRotate Parms{};

	Parms.Enable = Enable;

	UObject::ProcessEvent(Func, &Parms);

	if (NewParam1 != nullptr)
		*NewParam1 = Parms.NewParam1;
}


// Function AbstractCharacter.AbstractCharacter_C.SetExecuteFXEnable(Overloaded)
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Enable                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetExecuteFXEnable_Overloaded_(bool Enable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetExecuteFXEnable(Overloaded)");

	Params::AbstractCharacter_C_SetExecuteFXEnable_Overloaded_ Parms{};

	Parms.Enable = Enable;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetExecuteFXVariableLinkage(Overloaded)
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             InVariableName                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   InValue                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetExecuteFXVariableLinkage_Overloaded_(class FName InVariableName, float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetExecuteFXVariableLinkage(Overloaded)");

	Params::AbstractCharacter_C_SetExecuteFXVariableLinkage_Overloaded_ Parms{};

	Parms.InVariableName = InVariableName;
	Parms.InValue = InValue;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetForceIdleAnim
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimSequenceBase*                Animation                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// EMovementMode                           ForceMovementMode                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetForceIdleAnim(class UAnimSequenceBase* Animation, EMovementMode ForceMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetForceIdleAnim");

	Params::AbstractCharacter_C_SetForceIdleAnim Parms{};

	Parms.Animation = Animation;
	Parms.ForceMovementMode = ForceMovementMode;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetHp
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetHp(double NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetHp");

	Params::AbstractCharacter_C_SetHp Parms{};

	Parms.NewValue = NewValue;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetMontageDurationFunction
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UObject*                          Object                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class FString&                    FunctionName                                           (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const float                             InDelayedToStart                                       (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const float                             InDelayedToEnd                                         (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// TSubclassOf<class UAnimNotify_PlayMontageNotify>NotifyEnd                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash)
// struct FMontageDurationHandle*          Handler                                                (Parm, OutParm, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetMontageDurationFunction(class UObject* Object, const class FString& FunctionName, const float InDelayedToStart, const float InDelayedToEnd, TSubclassOf<class UAnimNotify_PlayMontageNotify> NotifyEnd, struct FMontageDurationHandle* Handler)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetMontageDurationFunction");

	Params::AbstractCharacter_C_SetMontageDurationFunction Parms{};

	Parms.Object = Object;
	Parms.FunctionName = std::move(FunctionName);
	Parms.InDelayedToStart = InDelayedToStart;
	Parms.InDelayedToEnd = InDelayedToEnd;
	Parms.NotifyEnd = NotifyEnd;

	UObject::ProcessEvent(Func, &Parms);

	if (Handler != nullptr)
		*Handler = std::move(Parms.Handler);
}


// Function AbstractCharacter.AbstractCharacter_C.SetPerfectTimeEffectFX
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Active                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetPerfectTimeEffectFX(bool Active)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetPerfectTimeEffectFX");

	Params::AbstractCharacter_C_SetPerfectTimeEffectFX Parms{};

	Parms.Active = Active;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetRotateMode
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_RotationMode                          Mode                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetRotateMode(E_RotationMode Mode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetRotateMode");

	Params::AbstractCharacter_C_SetRotateMode Parms{};

	Parms.Mode = Mode;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SetSelectedByTarget
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Selected                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SetSelectedByTarget(bool Selected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SetSelectedByTarget");

	Params::AbstractCharacter_C_SetSelectedByTarget Parms{};

	Parms.Selected = Selected;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.SlowDownRagdollSpeedWhenFullOpen
// (Private, HasDefaults, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::SlowDownRagdollSpeedWhenFullOpen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SlowDownRagdollSpeedWhenFullOpen");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.SpawnAnimActor
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UClass*                           ItemClass                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class FName                             AttachToSocket                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::SpawnAnimActor(class UClass* ItemClass, class FName AttachToSocket)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "SpawnAnimActor");

	Params::AbstractCharacter_C_SpawnAnimActor Parms{};

	Parms.ItemClass = ItemClass;
	Parms.AttachToSocket = AttachToSocket;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.StartArcaneshiftEffect
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::StartArcaneshiftEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "StartArcaneshiftEffect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_AttackResult
// (Net, NetReliable, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_AttackResult                          Result                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_AttackResult(E_AttackResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_AttackResult");

	Params::AbstractCharacter_C_Sync_AttackResult Parms{};

	Parms.Result = Result;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_CharacterDeath
// (Net, NetReliable, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     MontageToPlay                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_CharacterDeath(class UAnimMontage* MontageToPlay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_CharacterDeath");

	Params::AbstractCharacter_C_Sync_CharacterDeath Parms{};

	Parms.MontageToPlay = MontageToPlay;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_DecayedImpactVelocity
// (Net, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector_NetQuantize100&    InMaxVelocity                                          (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// class UCurveFloat*                      InAlphaCurve                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const float                             InMaxDuration                                          (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_DecayedImpactVelocity(const struct FVector_NetQuantize100& InMaxVelocity, class UCurveFloat* InAlphaCurve, const float InMaxDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_DecayedImpactVelocity");

	Params::AbstractCharacter_C_Sync_DecayedImpactVelocity Parms{};

	Parms.InMaxVelocity = std::move(InMaxVelocity);
	Parms.InAlphaCurve = InAlphaCurve;
	Parms.InMaxDuration = InMaxDuration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_ForceActingPlay
// (Net, NetReliable, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           TargetActor                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     MainMontageToPlay                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UAnimSequenceBase*                TargetMontageToPlay                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_PairedAnimMovingType                  PrepareMove                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    DelayedTargetExecuteMontage                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_ForceActingPlay(class AActor* TargetActor, class UAnimMontage* MainMontageToPlay, class UAnimSequenceBase* TargetMontageToPlay, E_PairedAnimMovingType PrepareMove, bool DelayedTargetExecuteMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_ForceActingPlay");

	Params::AbstractCharacter_C_Sync_ForceActingPlay Parms{};

	Parms.TargetActor = TargetActor;
	Parms.MainMontageToPlay = MainMontageToPlay;
	Parms.TargetMontageToPlay = TargetMontageToPlay;
	Parms.PrepareMove = PrepareMove;
	Parms.DelayedTargetExecuteMontage = DelayedTargetExecuteMontage;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_JumpToSection
// (Net, NetReliable, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             SectionName                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_JumpToSection(class FName SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_JumpToSection");

	Params::AbstractCharacter_C_Sync_JumpToSection Parms{};

	Parms.SectionName = SectionName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_MontagePlay
// (Net, NetReliable, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     MontageToPlay                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    JumpSection                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             SectionName                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_MontagePlay(class UAnimMontage* MontageToPlay, bool JumpSection, class FName SectionName, E_MontageAction Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_MontagePlay");

	Params::AbstractCharacter_C_Sync_MontagePlay Parms{};

	Parms.MontageToPlay = MontageToPlay;
	Parms.JumpSection = JumpSection;
	Parms.SectionName = SectionName;
	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_ResetBS
// (Net, NetReliable, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    BSKey                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    Immediately                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_ResetBS(const class FString& BSKey, bool Immediately)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_ResetBS");

	Params::AbstractCharacter_C_Sync_ResetBS Parms{};

	Parms.BSKey = std::move(BSKey);
	Parms.Immediately = Immediately;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Sync_SwitchBS
// (Net, NetReliable, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBlendSpace*                      NewBS                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class FString&                    BSKey                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    Immediately                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Sync_SwitchBS(class UBlendSpace* NewBS, const class FString& BSKey, bool Immediately)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Sync_SwitchBS");

	Params::AbstractCharacter_C_Sync_SwitchBS Parms{};

	Parms.NewBS = NewBS;
	Parms.BSKey = std::move(BSKey);
	Parms.Immediately = Immediately;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.TakeDamage
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FF_HitData&                      Emery_HitData_Processed                                (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)
// const struct FHitResult&                HitResult                                              (BlueprintVisible, BlueprintReadOnly, Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference)
// E_AttackResult*                         ResultType                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::TakeDamage(struct FF_HitData& Emery_HitData_Processed, const struct FHitResult& HitResult, E_AttackResult* ResultType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "TakeDamage");

	Params::AbstractCharacter_C_TakeDamage Parms{};

	Parms.Emery_HitData_Processed = std::move(Emery_HitData_Processed);
	Parms.HitResult = std::move(HitResult);

	UObject::ProcessEvent(Func, &Parms);

	Emery_HitData_Processed = std::move(Parms.Emery_HitData_Processed);

	if (ResultType != nullptr)
		*ResultType = Parms.ResultType;
}


// Function AbstractCharacter.AbstractCharacter_C.TakeDamageTypeStateCheck
// (Private, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FF_HitData&                F_HitData                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)
// E_AttackResult*                         ResultType                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::TakeDamageTypeStateCheck(const struct FF_HitData& F_HitData, E_AttackResult* ResultType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "TakeDamageTypeStateCheck");

	Params::AbstractCharacter_C_TakeDamageTypeStateCheck Parms{};

	Parms.F_HitData = std::move(F_HitData);

	UObject::ProcessEvent(Func, &Parms);

	if (ResultType != nullptr)
		*ResultType = Parms.ResultType;
}


// Function AbstractCharacter.AbstractCharacter_C.TakeDirectDamage
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const float                             InValue                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class AActor*                     InCauser                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::TakeDirectDamage(const float InValue, const class AActor* InCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "TakeDirectDamage");

	Params::AbstractCharacter_C_TakeDirectDamage Parms{};

	Parms.InValue = InValue;
	Parms.InCauser = InCauser;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.ThisFeedbackIsPlaying
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UForceFeedbackEffect*             Effect                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::ThisFeedbackIsPlaying(class UForceFeedbackEffect* Effect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ThisFeedbackIsPlaying");

	Params::AbstractCharacter_C_ThisFeedbackIsPlaying Parms{};

	Parms.Effect = Effect;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.Transmit_SponsorActingEffectToApplier
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Applier                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Transmit_SponsorActingEffectToApplier(int32 SkillID, class AActor* Applier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Transmit_SponsorActingEffectToApplier");

	Params::AbstractCharacter_C_Transmit_SponsorActingEffectToApplier Parms{};

	Parms.SkillID = SkillID;
	Parms.Applier = Applier;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.Transmit_TakeDamage
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Attacker                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FSS_TakeDamage&            NetworkDamageData                                      (BlueprintVisible, BlueprintReadOnly, Parm, ContainsInstancedReference, HasGetValueTypeHash)

void AAbstractCharacter_C::Transmit_TakeDamage(class AActor* Attacker, const struct FSS_TakeDamage& NetworkDamageData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Transmit_TakeDamage");

	Params::AbstractCharacter_C_Transmit_TakeDamage Parms{};

	Parms.Attacker = Attacker;
	Parms.NetworkDamageData = std::move(NetworkDamageData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.TryEffectAfterDamage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Applier                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_StunType                              ReflectType                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   hit_data_id                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   Impact_Direction                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Applied                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::TryEffectAfterDamage(class AActor* Applier, E_StunType ReflectType, int32 hit_data_id, const struct FVector& Impact_Direction, bool* Applied)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "TryEffectAfterDamage");

	Params::AbstractCharacter_C_TryEffectAfterDamage Parms{};

	Parms.Applier = Applier;
	Parms.ReflectType = ReflectType;
	Parms.hit_data_id = hit_data_id;
	Parms.Impact_Direction = std::move(Impact_Direction);

	UObject::ProcessEvent(Func, &Parms);

	if (Applied != nullptr)
		*Applied = Parms.Applied;
}


// Function AbstractCharacter.AbstractCharacter_C.TryPerfectTimeAnimSection
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     Montage                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class FName*                            SectionName                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::TryPerfectTimeAnimSection(class UAnimMontage* Montage, class FName* SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "TryPerfectTimeAnimSection");

	Params::AbstractCharacter_C_TryPerfectTimeAnimSection Parms{};

	Parms.Montage = Montage;

	UObject::ProcessEvent(Func, &Parms);

	if (SectionName != nullptr)
		*SectionName = Parms.SectionName;
}


// Function AbstractCharacter.AbstractCharacter_C.Undelayed_TakeDamage
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FF_HitData&                      Emery_HitData_Processed                                (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, ContainsInstancedReference, HasGetValueTypeHash)
// const struct FHitResult&                HitResult                                              (BlueprintVisible, BlueprintReadOnly, Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference)
// E_AttackResult*                         ResultType                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::Undelayed_TakeDamage(struct FF_HitData& Emery_HitData_Processed, const struct FHitResult& HitResult, E_AttackResult* ResultType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "Undelayed_TakeDamage");

	Params::AbstractCharacter_C_Undelayed_TakeDamage Parms{};

	Parms.Emery_HitData_Processed = std::move(Emery_HitData_Processed);
	Parms.HitResult = std::move(HitResult);

	UObject::ProcessEvent(Func, &Parms);

	Emery_HitData_Processed = std::move(Parms.Emery_HitData_Processed);

	if (ResultType != nullptr)
		*ResultType = Parms.ResultType;
}


// Function AbstractCharacter.AbstractCharacter_C.UpdateCapsuleCollisionWhenDeath
// (Public, BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::UpdateCapsuleCollisionWhenDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "UpdateCapsuleCollisionWhenDeath");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AbstractCharacter.AbstractCharacter_C.UpdateCharacterDynamicMark
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              MarkTag                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// bool                                    Add                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           HitTarget                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::UpdateCharacterDynamicMark(const struct FGameplayTag& MarkTag, bool Add, class AActor* HitTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "UpdateCharacterDynamicMark");

	Params::AbstractCharacter_C_UpdateCharacterDynamicMark Parms{};

	Parms.MarkTag = std::move(MarkTag);
	Parms.Add = Add;
	Parms.HitTarget = HitTarget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.UpdateCollisionDeathType
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UAnimMontage*               Montage                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::UpdateCollisionDeathType(const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "UpdateCollisionDeathType");

	Params::AbstractCharacter_C_UpdateCollisionDeathType Parms{};

	Parms.Montage = Montage;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.UpdateRagdollDamping
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Level                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::UpdateRagdollDamping(int32 Level)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "UpdateRagdollDamping");

	Params::AbstractCharacter_C_UpdateRagdollDamping Parms{};

	Parms.Level = Level;

	UObject::ProcessEvent(Func, &Parms);
}


// Function AbstractCharacter.AbstractCharacter_C.UsePhysyicEffectWhenAppliedDamage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool AAbstractCharacter_C::UsePhysyicEffectWhenAppliedDamage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "UsePhysyicEffectWhenAppliedDamage");

	Params::AbstractCharacter_C_UsePhysyicEffectWhenAppliedDamage Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AbstractCharacter.AbstractCharacter_C.ValidCharacterDynamicMark
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              MarkTag                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// bool*                                   Valid                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void AAbstractCharacter_C::ValidCharacterDynamicMark(const struct FGameplayTag& MarkTag, bool* Valid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "ValidCharacterDynamicMark");

	Params::AbstractCharacter_C_ValidCharacterDynamicMark Parms{};

	Parms.MarkTag = std::move(MarkTag);

	UObject::ProcessEvent(Func, &Parms);

	if (Valid != nullptr)
		*Valid = Parms.Valid;
}


// Function AbstractCharacter.AbstractCharacter_C.WhenFullyOpenSimulatePhysicsEvent
// (BlueprintCallable, BlueprintEvent)

void AAbstractCharacter_C::WhenFullyOpenSimulatePhysicsEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbstractCharacter_C", "WhenFullyOpenSimulatePhysicsEvent");

	UObject::ProcessEvent(Func, nullptr);
}

}