#pragma once

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

// Package: BP_CombatCharacter

#include "Basic.hpp"

#include "BP_CombatCharacter_classes.hpp"
#include "BP_CombatCharacter_parameters.hpp"


namespace SDK
{

// Function BP_CombatCharacter.BP_CombatCharacter_C.AddAccessActivity
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const EDCSActivityType                  AddAct                                                 (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::AddAccessActivity(const EDCSActivityType AddAct)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "AddAccessActivity");

	Params::BP_CombatCharacter_C_AddAccessActivity Parms{};

	Parms.AddAct = AddAct;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.AddShapeMesh
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USkeletalMesh*                    SkeletalMesh                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UClass*                           NewClass                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class USkeletalMeshComponent*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash)

class USkeletalMeshComponent* ABP_CombatCharacter_C::AddShapeMesh(class USkeletalMesh* SkeletalMesh, class UClass* NewClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "AddShapeMesh");

	Params::BP_CombatCharacter_C_AddShapeMesh Parms{};

	Parms.SkeletalMesh = SkeletalMesh;
	Parms.NewClass = NewClass;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.AttachLockDisplayComponent
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           ParentActor                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class USceneComponent*                  ParentComponent_0                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class FName                             AttachSocket                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::AttachLockDisplayComponent(class AActor* ParentActor, class USceneComponent* ParentComponent_0, class FName AttachSocket, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "AttachLockDisplayComponent");

	Params::BP_CombatCharacter_C_AttachLockDisplayComponent Parms{};

	Parms.ParentActor = ParentActor;
	Parms.ParentComponent_0 = ParentComponent_0;
	Parms.AttachSocket = AttachSocket;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.AttemptBackstab
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::AttemptBackstab(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "AttemptBackstab");

	Params::BP_CombatCharacter_C_AttemptBackstab Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.AttemptExecute
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::AttemptExecute(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "AttemptExecute");

	Params::BP_CombatCharacter_C_AttemptExecute Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BeginInteract
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::BeginInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BeginInteract");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.bLock
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::bLock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "bLock");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__BP_CombatCharacter_InputBuffer_K2Node_ComponentBoundEvent_0_OnBreakableAnim__DelegateSignature
// (BlueprintEvent)

void ABP_CombatCharacter_C::BndEvt__BP_CombatCharacter_InputBuffer_K2Node_ComponentBoundEvent_0_OnBreakableAnim__DelegateSignature()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__BP_CombatCharacter_InputBuffer_K2Node_ComponentBoundEvent_0_OnBreakableAnim__DelegateSignature");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__BP_CombatCharacter_InputBuffer_K2Node_ComponentBoundEvent_0_OnInputBufferCloseAndConsumed__DelegateSignature
// (BlueprintEvent)
// Parameters:
// E_InputBufferKey                        Key                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    AttackCounterAccelerate_0                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  AttackCounterAccelerateRate                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Breakable                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::BndEvt__BP_CombatCharacter_InputBuffer_K2Node_ComponentBoundEvent_0_OnInputBufferCloseAndConsumed__DelegateSignature(E_InputBufferKey Key, bool AttackCounterAccelerate_0, double AttackCounterAccelerateRate, bool Breakable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__BP_CombatCharacter_InputBuffer_K2Node_ComponentBoundEvent_0_OnInputBufferCloseAndConsumed__DelegateSignature");

	Params::BP_CombatCharacter_C_BndEvt__BP_CombatCharacter_InputBuffer_K2Node_ComponentBoundEvent_0_OnInputBufferCloseAndConsumed__DelegateSignature Parms{};

	Parms.Key = Key;
	Parms.AttackCounterAccelerate_0 = AttackCounterAccelerate_0;
	Parms.AttackCounterAccelerateRate = AttackCounterAccelerateRate;
	Parms.Breakable = Breakable;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__BP_CombatCharacter_SpringArmsComponent_K2Node_ComponentBoundEvent_0_OnLockingTargetValidUpdated__DelegateSignature
// (BlueprintEvent)
// Parameters:
// bool                                    Valid                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::BndEvt__BP_CombatCharacter_SpringArmsComponent_K2Node_ComponentBoundEvent_0_OnLockingTargetValidUpdated__DelegateSignature(bool Valid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__BP_CombatCharacter_SpringArmsComponent_K2Node_ComponentBoundEvent_0_OnLockingTargetValidUpdated__DelegateSignature");

	Params::BP_CombatCharacter_C_BndEvt__BP_CombatCharacter_SpringArmsComponent_K2Node_ComponentBoundEvent_0_OnLockingTargetValidUpdated__DelegateSignature Parms{};

	Parms.Valid = Valid;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__CapsuleComponent_K2Node_ComponentBoundEvent_2_ComponentHitSignature__DelegateSignature
// (HasOutParams, BlueprintEvent)
// Parameters:
// class UPrimitiveComponent*              HitComponent                                           (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)
// const struct FVector&                   NormalImpulse                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FHitResult&                Hit                                                    (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference)

void ABP_CombatCharacter_C::BndEvt__CapsuleComponent_K2Node_ComponentBoundEvent_2_ComponentHitSignature__DelegateSignature(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__CapsuleComponent_K2Node_ComponentBoundEvent_2_ComponentHitSignature__DelegateSignature");

	Params::BP_CombatCharacter_C_BndEvt__CapsuleComponent_K2Node_ComponentBoundEvent_2_ComponentHitSignature__DelegateSignature Parms{};

	Parms.HitComponent = HitComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__DynamicTargeting_K2Node_ComponentBoundEvent_61_OnTargetingToggled__DelegateSignature
// (BlueprintEvent)
// Parameters:
// bool                                    Enabled                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::BndEvt__DynamicTargeting_K2Node_ComponentBoundEvent_61_OnTargetingToggled__DelegateSignature(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__DynamicTargeting_K2Node_ComponentBoundEvent_61_OnTargetingToggled__DelegateSignature");

	Params::BP_CombatCharacter_C_BndEvt__DynamicTargeting_K2Node_ComponentBoundEvent_61_OnTargetingToggled__DelegateSignature Parms{};

	Parms.Enabled = Enabled;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__InputBuffer_K2Node_ComponentBoundEvent_1_OnInputBufferPreConsumeRequest__DelegateSignature
// (BlueprintEvent)
// Parameters:
// int32                                   RequestVersion                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_InputBufferKey                        Key                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_State                                 BreakableState_0                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::BndEvt__InputBuffer_K2Node_ComponentBoundEvent_1_OnInputBufferPreConsumeRequest__DelegateSignature(int32 RequestVersion, E_InputBufferKey Key, E_State BreakableState_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__InputBuffer_K2Node_ComponentBoundEvent_1_OnInputBufferPreConsumeRequest__DelegateSignature");

	Params::BP_CombatCharacter_C_BndEvt__InputBuffer_K2Node_ComponentBoundEvent_1_OnInputBufferPreConsumeRequest__DelegateSignature Parms{};

	Parms.RequestVersion = RequestVersion;
	Parms.Key = Key;
	Parms.BreakableState_0 = BreakableState_0;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__InputBuffer_K2Node_ComponentBoundEvent_2_OnInputBufferConsumed__DelegateSignature
// (BlueprintEvent)
// Parameters:
// E_InputBufferKey                        Key                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::BndEvt__InputBuffer_K2Node_ComponentBoundEvent_2_OnInputBufferConsumed__DelegateSignature(E_InputBufferKey Key)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__InputBuffer_K2Node_ComponentBoundEvent_2_OnInputBufferConsumed__DelegateSignature");

	Params::BP_CombatCharacter_C_BndEvt__InputBuffer_K2Node_ComponentBoundEvent_2_OnInputBufferConsumed__DelegateSignature Parms{};

	Parms.Key = Key;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BndEvt__InputBuffer_K2Node_ComponentBoundEvent_4_OnInputBufferClose__DelegateSignature
// (BlueprintEvent)

void ABP_CombatCharacter_C::BndEvt__InputBuffer_K2Node_ComponentBoundEvent_4_OnInputBufferClose__DelegateSignature()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BndEvt__InputBuffer_K2Node_ComponentBoundEvent_4_OnInputBufferClose__DelegateSignature");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.BP_CombatCharacter_AutoGenFunc
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    NewAIAlertBattle                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::BP_CombatCharacter_AutoGenFunc(bool NewAIAlertBattle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BP_CombatCharacter_AutoGenFunc");

	Params::BP_CombatCharacter_C_BP_CombatCharacter_AutoGenFunc Parms{};

	Parms.NewAIAlertBattle = NewAIAlertBattle;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.BreakImmersionMainUI
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::BreakImmersionMainUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "BreakImmersionMainUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CalculateLeanAmount
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 LeanAmount                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 InterpSpeed                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CalculateLeanAmount(double* LeanAmount, double* InterpSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CalculateLeanAmount");

	Params::BP_CombatCharacter_C_CalculateLeanAmount Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CallGameSettingValueInit
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::CallGameSettingValueInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CallGameSettingValueInit");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CallSync_JumpToHeavyAttackSection
// (Net, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     Montage                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CallSync_JumpToHeavyAttackSection(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CallSync_JumpToHeavyAttackSection");

	Params::BP_CombatCharacter_C_CallSync_JumpToHeavyAttackSection Parms{};

	Parms.Montage = Montage;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CallSync_StopAnimMontage
// (Net, NetServer, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::CallSync_StopAnimMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CallSync_StopAnimMontage");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CallSync_StopMontage
// (Net, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UAnimMontage*               Montage                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CallSync_StopMontage(const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CallSync_StopMontage");

	Params::BP_CombatCharacter_C_CallSync_StopMontage Parms{};

	Parms.Montage = Montage;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.camera smooth__FinishedFunc
// (BlueprintEvent)

void ABP_CombatCharacter_C::camera_smooth__FinishedFunc()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "camera smooth__FinishedFunc");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.camera smooth__UpdateFunc
// (BlueprintEvent)

void ABP_CombatCharacter_C::camera_smooth__UpdateFunc()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "camera smooth__UpdateFunc");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CameraIsShoulderViewWhenLock
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::CameraIsShoulderViewWhenLock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CameraIsShoulderViewWhenLock");

	Params::BP_CombatCharacter_C_CameraIsShoulderViewWhenLock Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CameraIsTargetingLock
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   return_value                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CameraIsTargetingLock(bool* return_value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CameraIsTargetingLock");

	Params::BP_CombatCharacter_C_CameraIsTargetingLock Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanBowAttack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanBowAttack(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanBowAttack");

	Params::BP_CombatCharacter_C_CanBowAttack Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanCastAbility
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanCastAbility(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanCastAbility");

	Params::BP_CombatCharacter_C_CanCastAbility Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanCharge
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanCharge(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanCharge");

	Params::BP_CombatCharacter_C_CanCharge Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanMeleeAttack
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  WillCostStamina                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    exclusive_empty_handed                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EDCSActionType                          Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanMeleeAttack(double WillCostStamina, bool exclusive_empty_handed, EDCSActionType Action, bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanMeleeAttack");

	Params::BP_CombatCharacter_C_CanMeleeAttack Parms{};

	Parms.WillCostStamina = WillCostStamina;
	Parms.exclusive_empty_handed = exclusive_empty_handed;
	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanOpenUI
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanOpenUI(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanOpenUI");

	Params::BP_CombatCharacter_C_CanOpenUI Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanRoll
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanRoll(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanRoll");

	Params::BP_CombatCharacter_C_CanRoll Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanSlowDown
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanSlowDown(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanSlowDown");

	Params::BP_CombatCharacter_C_CanSlowDown Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CanUseOrSwitchItem
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CanUseOrSwitchItem(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CanUseOrSwitchItem");

	Params::BP_CombatCharacter_C_CanUseOrSwitchItem Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ChangeSpellBS
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Time                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ChangeSpellBS(double Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ChangeSpellBS");

	Params::BP_CombatCharacter_C_ChangeSpellBS Parms{};

	Parms.Time = Time;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Charge
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Charge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Charge");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CheckExecuteCandition_Tick
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::CheckExecuteCandition_Tick()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CheckExecuteCandition_Tick");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CheckExecuteCondition
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   CanExecute                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32*                                  SkillID                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AAbstractCharacter_C**            OutTarget                                              (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CheckExecuteCondition(bool* CanExecute, int32* SkillID, class AAbstractCharacter_C** OutTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CheckExecuteCondition");

	Params::BP_CombatCharacter_C_CheckExecuteCondition Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CheckExecuteHeightDelta
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AAbstractCharacter_C*             TargetCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  HeightDelta                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::CheckExecuteHeightDelta(class AAbstractCharacter_C* TargetCharacter, double HeightDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CheckExecuteHeightDelta");

	Params::BP_CombatCharacter_C_CheckExecuteHeightDelta Parms{};

	Parms.TargetCharacter = TargetCharacter;
	Parms.HeightDelta = HeightDelta;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CheckPerfectBuffComsumeByNextWeaponSkill
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Success                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CheckPerfectBuffComsumeByNextWeaponSkill(bool* Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CheckPerfectBuffComsumeByNextWeaponSkill");

	Params::BP_CombatCharacter_C_CheckPerfectBuffComsumeByNextWeaponSkill Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CheckResetLastRollDirection
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_InputBufferKey                        BufferKey                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::CheckResetLastRollDirection(E_InputBufferKey BufferKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CheckResetLastRollDirection");

	Params::BP_CombatCharacter_C_CheckResetLastRollDirection Parms{};

	Parms.BufferKey = BufferKey;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CheckWidgetQueueFinished
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::CheckWidgetQueueFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CheckWidgetQueueFinished");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ChooseMontageIndex_override
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// int32*                                  Index_0                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ChooseMontageIndex_override(const struct FGameplayTag& Tag, int32* Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ChooseMontageIndex_override");

	Params::BP_CombatCharacter_C_ChooseMontageIndex_override Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ClambLadder
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ClambLadder()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ClambLadder");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ClearCachedInputRightBeforeDisableInput
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ClearCachedInputRightBeforeDisableInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ClearCachedInputRightBeforeDisableInput");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ClearMovementStartEndPlay
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ClearMovementStartEndPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ClearMovementStartEndPlay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ClosedUI
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ClosedUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ClosedUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ConsumeWL
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   NowNum                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   ConsumeNum                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   if_play                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32*                                  NewNum                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ConsumeWL(int32 NowNum, int32 ConsumeNum, bool* if_play, int32* NewNum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ConsumeWL");

	Params::BP_CombatCharacter_C_ConsumeWL Parms{};

	Parms.NowNum = NowNum;
	Parms.ConsumeNum = ConsumeNum;

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.coverMontageDataTable
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UDataTable*                       InDataTable                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UDataTable**                      OutDataTable                                           (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::coverMontageDataTable(class UDataTable* InDataTable, class UDataTable** OutDataTable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "coverMontageDataTable");

	Params::BP_CombatCharacter_C_coverMontageDataTable Parms{};

	Parms.InDataTable = InDataTable;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CreateDeathUI
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::CreateDeathUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CreateDeathUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CreateNoticeForObj
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FText&                      Content                                                (BlueprintVisible, BlueprintReadOnly, Parm)

void ABP_CombatCharacter_C::CreateNoticeForObj(const class FText& Content)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CreateNoticeForObj");

	Params::BP_CombatCharacter_C_CreateNoticeForObj Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.CreateWidget
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::CreateWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CreateWidget");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.CustomJump
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::CustomJump()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "CustomJump");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.DelayShowGameUIEvent
// (Private, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::DelayShowGameUIEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "DelayShowGameUIEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.DetachLockDisplayComponent
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           ParentActor                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::DetachLockDisplayComponent(class AActor* ParentActor, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "DetachLockDisplayComponent");

	Params::BP_CombatCharacter_C_DetachLockDisplayComponent Parms{};

	Parms.ParentActor = ParentActor;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Do Buffer Input Main
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_InputBufferKey                        NewParam                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Do_Buffer_Input_Main(E_InputBufferKey NewParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Do Buffer Input Main");

	Params::BP_CombatCharacter_C_Do_Buffer_Input_Main Parms{};

	Parms.NewParam = NewParam;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.DoDirectionalLightIntensity
// (Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  DL_Player                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  DL_AINPC                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::DoDirectionalLightIntensity(double DL_Player, double DL_AINPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "DoDirectionalLightIntensity");

	Params::BP_CombatCharacter_C_DoDirectionalLightIntensity Parms{};

	Parms.DL_Player = DL_Player;
	Parms.DL_AINPC = DL_AINPC;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.DoesHoldBowString
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::DoesHoldBowString(bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "DoesHoldBowString");

	Params::BP_CombatCharacter_C_DoesHoldBowString Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.EnableCameraArmCheck
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::EnableCameraArmCheck()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "EnableCameraArmCheck");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.EndInteract
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::EndInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "EndInteract");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.EndRebornFireEvent
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::EndRebornFireEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "EndRebornFireEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.EquipExecuteWeapon
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::EquipExecuteWeapon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "EquipExecuteWeapon");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ExecuteUbergraph_BP_CombatCharacter
// (Final, UbergraphFunction, HasDefaults)
// Parameters:
// int32                                   EntryPoint                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ExecuteUbergraph_BP_CombatCharacter(int32 EntryPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ExecuteUbergraph_BP_CombatCharacter");

	Params::BP_CombatCharacter_C_ExecuteUbergraph_BP_CombatCharacter Parms{};

	Parms.EntryPoint = EntryPoint;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.FeatherEffect
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Count                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::FeatherEffect(double Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "FeatherEffect");

	Params::BP_CombatCharacter_C_FeatherEffect Parms{};

	Parms.Count = Count;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.FindStateByString
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    StringState                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// E_State*                                EState                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::FindStateByString(const class FString& StringState, E_State* EState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "FindStateByString");

	Params::BP_CombatCharacter_C_FindStateByString Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.FinishLadder
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::FinishLadder()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "FinishLadder");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Fix Camera Lag Sprint
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Fix_Camera_Lag_Sprint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Fix Camera Lag Sprint");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Force Acting Effect
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           BackstabbedActor_0                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_EffectType                            Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Force_Acting_Effect(class AActor* BackstabbedActor_0, E_EffectType Type, int32 SkillID, bool* Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Force Acting Effect");

	Params::BP_CombatCharacter_C_Force_Acting_Effect Parms{};

	Parms.BackstabbedActor_0 = BackstabbedActor_0;
	Parms.Type = Type;
	Parms.SkillID = SkillID;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Force Quit If Exist Duplicate Player
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Force_Quit_If_Exist_Duplicate_Player()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Force Quit If Exist Duplicate Player");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ForceUseShoulderView
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::ForceUseShoulderView()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ForceUseShoulderView");

	Params::BP_CombatCharacter_C_ForceUseShoulderView Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ForwardDirectionInputAxisValue_OnServer
// (Net, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ForwardDirectionInputAxisValue_OnServer(double NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ForwardDirectionInputAxisValue_OnServer");

	Params::BP_CombatCharacter_C_ForwardDirectionInputAxisValue_OnServer Parms{};

	Parms.NewValue = NewValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ForwardDirectionInputAxisValue_RepSet
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ForwardDirectionInputAxisValue_RepSet(double NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ForwardDirectionInputAxisValue_RepSet");

	Params::BP_CombatCharacter_C_ForwardDirectionInputAxisValue_RepSet Parms{};

	Parms.NewValue = NewValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Get Active Weapon
// (Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// int32*                                  WeaponSortId                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Get_Active_Weapon(int32* WeaponSortId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Get Active Weapon");

	Params::BP_CombatCharacter_C_Get_Active_Weapon Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Get My New Item Show Tag Component
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UNewItemShowTagComponent_C**      Component                                              (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Get_My_New_Item_Show_Tag_Component(class UNewItemShowTagComponent_C** Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Get My New Item Show Tag Component");

	Params::BP_CombatCharacter_C_Get_My_New_Item_Show_Tag_Component Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Get Player Montage from Game Play Tag
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              game_play_tag                                          (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// int32                                   MontageIndex                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage**                    Montage                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Get_Player_Montage_from_Game_Play_Tag(const struct FGameplayTag& game_play_tag, int32 MontageIndex, class UAnimMontage** Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Get Player Montage from Game Play Tag");

	Params::BP_CombatCharacter_C_Get_Player_Montage_from_Game_Play_Tag Parms{};

	Parms.game_play_tag = std::move(game_play_tag);
	Parms.MontageIndex = MontageIndex;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetAimAlpha
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetAimAlpha(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetAimAlpha");

	Params::BP_CombatCharacter_C_GetAimAlpha Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetAimTarget
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector*                         Bullet_From                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector*                         Bullet_To                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetAimTarget(struct FVector* Bullet_From, struct FVector* Bullet_To, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetAimTarget");

	Params::BP_CombatCharacter_C_GetAimTarget Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetAllSocketLocation_Targetable
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Distance                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// TArray<struct FVector>*                 Locations                                              (Parm, OutParm)
// TArray<bool>*                           CanUse                                                 (Parm, OutParm)

void ABP_CombatCharacter_C::GetAllSocketLocation_Targetable(double Distance, TArray<struct FVector>* Locations, TArray<bool>* CanUse)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetAllSocketLocation_Targetable");

	Params::BP_CombatCharacter_C_GetAllSocketLocation_Targetable Parms{};

	Parms.Distance = Distance;

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetBlockMontage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage**                    Montage                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetBlockMontage(class UAnimMontage** Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetBlockMontage");

	Params::BP_CombatCharacter_C_GetBlockMontage Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetBowStringSocketName
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName*                            Name_0                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetBowStringSocketName(class FName* Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetBowStringSocketName");

	Params::BP_CombatCharacter_C_GetBowStringSocketName Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetCameraTargetingLockedActor
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AActor**                          SelectedActor                                          (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetCameraTargetingLockedActor(class AActor** SelectedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetCameraTargetingLockedActor");

	Params::BP_CombatCharacter_C_GetCameraTargetingLockedActor Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetCastingSpeed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetCastingSpeed(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetCastingSpeed");

	Params::BP_CombatCharacter_C_GetCastingSpeed Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetChargeMontage
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage**                    ChargeMontage                                          (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetChargeMontage(class UAnimMontage** ChargeMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetChargeMontage");

	Params::BP_CombatCharacter_C_GetChargeMontage Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetCurrentMontageInstanceId
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

int32 ABP_CombatCharacter_C::GetCurrentMontageInstanceId()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetCurrentMontageInstanceId");

	Params::BP_CombatCharacter_C_GetCurrentMontageInstanceId Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetDesiredRotaion_Fix
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FRotator*                        Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor)

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

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetDesiredRotaion_Fix");

	Params::BP_CombatCharacter_C_GetDesiredRotaion_Fix Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetFootLocation
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector*                         Loc                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetFootLocation(struct FVector* Loc)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetFootLocation");

	Params::BP_CombatCharacter_C_GetFootLocation Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetFreemoveDirection
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// struct FVector*                         Direction                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetFreemoveDirection(struct FVector* Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetFreemoveDirection");

	Params::BP_CombatCharacter_C_GetFreemoveDirection Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetImpactMontage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage**                    Montage                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetImpactMontage(class UAnimMontage** Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetImpactMontage");

	Params::BP_CombatCharacter_C_GetImpactMontage Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetJogSpeed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 JogSpeed                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetJogSpeed(double* JogSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetJogSpeed");

	Params::BP_CombatCharacter_C_GetJogSpeed Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetLastMovementInput
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

struct FVector ABP_CombatCharacter_C::GetLastMovementInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetLastMovementInput");

	Params::BP_CombatCharacter_C_GetLastMovementInput Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetLevelSaver
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UPlugin_LevelSaver_C**            Plugin_LevelSaver                                      (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetLevelSaver(class UPlugin_LevelSaver_C** Plugin_LevelSaver)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetLevelSaver");

	Params::BP_CombatCharacter_C_GetLevelSaver Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetLightsActorIsOn
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   IsOpened                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetLightsActorIsOn(bool* IsOpened)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetLightsActorIsOn");

	Params::BP_CombatCharacter_C_GetLightsActorIsOn Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetLockedTargetInputDirection
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// struct FVector*                         Direction                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetLockedTargetInputDirection(struct FVector* Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetLockedTargetInputDirection");

	Params::BP_CombatCharacter_C_GetLockedTargetInputDirection Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMagicDamage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetMagicDamage(double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMagicDamage");

	Params::BP_CombatCharacter_C_GetMagicDamage Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMyEnhanceInput
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UEnhanceInputDispatcher_C**       EnhenceInputDispatcher                                 (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetMyEnhanceInput(class UEnhanceInputDispatcher_C** EnhenceInputDispatcher)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMyEnhanceInput");

	Params::BP_CombatCharacter_C_GetMyEnhanceInput Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMyHorizontalLook
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double ABP_CombatCharacter_C::GetMyHorizontalLook()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMyHorizontalLook");

	Params::BP_CombatCharacter_C_GetMyHorizontalLook Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMyLadderUp
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double ABP_CombatCharacter_C::GetMyLadderUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMyLadderUp");

	Params::BP_CombatCharacter_C_GetMyLadderUp Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMyMoveForward
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double ABP_CombatCharacter_C::GetMyMoveForward()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMyMoveForward");

	Params::BP_CombatCharacter_C_GetMyMoveForward Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMyMoveRight
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double ABP_CombatCharacter_C::GetMyMoveRight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMyMoveRight");

	Params::BP_CombatCharacter_C_GetMyMoveRight Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMyNpcFriend
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UNpcFriend_C**                    NpcFriend                                              (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetMyNpcFriend(class UNpcFriend_C** NpcFriend)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMyNpcFriend");

	Params::BP_CombatCharacter_C_GetMyNpcFriend Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetMyVerticalLook
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double ABP_CombatCharacter_C::GetMyVerticalLook()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetMyVerticalLook");

	Params::BP_CombatCharacter_C_GetMyVerticalLook Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetParriedMontage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage**                    Montage                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetParriedMontage(class UAnimMontage** Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetParriedMontage");

	Params::BP_CombatCharacter_C_GetParriedMontage Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetRebornFireWidget
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UWB_PlumeArchive_Main_C*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash)

class UWB_PlumeArchive_Main_C* ABP_CombatCharacter_C::GetRebornFireWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetRebornFireWidget");

	Params::BP_CombatCharacter_C_GetRebornFireWidget Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetRollMontage
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage**                    RollMontage                                            (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// E_MontageAction*                        OutRollDirection                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetRollMontage(class UAnimMontage** RollMontage, E_MontageAction* OutRollDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetRollMontage");

	Params::BP_CombatCharacter_C_GetRollMontage Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetShapeParentMesh
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash)

class USkeletalMeshComponent* ABP_CombatCharacter_C::GetShapeParentMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetShapeParentMesh");

	Params::BP_CombatCharacter_C_GetShapeParentMesh Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetSocketSelect_Targetable
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32*                                  SelectIndex                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetSocketSelect_Targetable(int32* SelectIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetSocketSelect_Targetable");

	Params::BP_CombatCharacter_C_GetSocketSelect_Targetable Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetSpawnedArrowTransform
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FTransform*                      Transform                                              (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetSpawnedArrowTransform(struct FTransform* Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetSpawnedArrowTransform");

	Params::BP_CombatCharacter_C_GetSpawnedArrowTransform Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetSpotParam
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Intensity                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Temperature                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetSpotParam(double* Intensity, double* Temperature)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetSpotParam");

	Params::BP_CombatCharacter_C_GetSpotParam Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetSprintSpeed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 SprintSpeed                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetSprintSpeed(double* SprintSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetSprintSpeed");

	Params::BP_CombatCharacter_C_GetSprintSpeed Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetTargetableCameraIndex_Override
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   OverrideIndex                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32*                                  ReturnIndex                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetTargetableCameraIndex_Override(bool* OverrideIndex, int32* ReturnIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetTargetableCameraIndex_Override");

	Params::BP_CombatCharacter_C_GetTargetableCameraIndex_Override Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetTargetLocation
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector*                         Location                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetTargetLocation(struct FVector* Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetTargetLocation");

	Params::BP_CombatCharacter_C_GetTargetLocation Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetTargetLocation_Attack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector*                         Location                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetTargetLocation_Attack(struct FVector* Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetTargetLocation_Attack");

	Params::BP_CombatCharacter_C_GetTargetLocation_Attack Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetThrowTargetLocation
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector*                         Location                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetThrowTargetLocation(struct FVector* Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetThrowTargetLocation");

	Params::BP_CombatCharacter_C_GetThrowTargetLocation Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetWaitingFlashMontage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Index_0                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage**                    Montage                                                (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetWaitingFlashMontage(int32 Index_0, class UAnimMontage** Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetWaitingFlashMontage");

	Params::BP_CombatCharacter_C_GetWaitingFlashMontage Parms{};

	Parms.Index_0 = Index_0;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.GetWalkSpeed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 WalkSpeed                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetWalkSpeed(double* WalkSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetWalkSpeed");

	Params::BP_CombatCharacter_C_GetWalkSpeed Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.HasAccess
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// EDCSActionType                          Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::HasAccess(EDCSActionType Action)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "HasAccess");

	Params::BP_CombatCharacter_C_HasAccess Parms{};

	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.HideCrosshair
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::HideCrosshair()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "HideCrosshair");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.HideMainWeapon
// (Private, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bNewHidden                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::HideMainWeapon(bool bNewHidden)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "HideMainWeapon");

	Params::BP_CombatCharacter_C_HideMainWeapon Parms{};

	Parms.bNewHidden = bNewHidden;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.IdleToMoveCallRollAction
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::IdleToMoveCallRollAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IdleToMoveCallRollAction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Impl Death
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Impl_Death()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Impl Death");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.impl get ladder position
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Position                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::impl_get_ladder_position(double* Position)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "impl get ladder position");

	Params::BP_CombatCharacter_C_impl_get_ladder_position Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ImplBreakpoint2
// (Event, Public, BlueprintEvent)
// Parameters:
// const class FString&                    InParam0                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    InParam1                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ImplBreakpoint2(const class FString& InParam0, const class FString& InParam1)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ImplBreakpoint2");

	Params::BP_CombatCharacter_C_ImplBreakpoint2 Parms{};

	Parms.InParam0 = std::move(InParam0);
	Parms.InParam1 = std::move(InParam1);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.InitBindGameSetting
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::InitBindGameSetting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InitBindGameSetting");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.InitializePlayer
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::InitializePlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InitializePlayer");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.InitializePlayer_OtherPlayer
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::InitializePlayer_OtherPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InitializePlayer_OtherPlayer");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.InnerPrintMovementLog
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::InnerPrintMovementLog()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InnerPrintMovementLog");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.InpActEvt_IP_Inventory_K2Node_EnhancedInputActionEvent_0
// (BlueprintEvent)
// Parameters:
// const struct FInputActionValue&         ActionValue                                            (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor)
// float                                   ElapsedTime                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   TriggeredTime                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class UInputAction*               SourceAction                                           (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::InpActEvt_IP_Inventory_K2Node_EnhancedInputActionEvent_0(const struct FInputActionValue& ActionValue, float ElapsedTime, float TriggeredTime, const class UInputAction* SourceAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InpActEvt_IP_Inventory_K2Node_EnhancedInputActionEvent_0");

	Params::BP_CombatCharacter_C_InpActEvt_IP_Inventory_K2Node_EnhancedInputActionEvent_0 Parms{};

	Parms.ActionValue = std::move(ActionValue);
	Parms.ElapsedTime = ElapsedTime;
	Parms.TriggeredTime = TriggeredTime;
	Parms.SourceAction = SourceAction;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.InpActEvt_IP_Thumbstick_Right_K2Node_EnhancedInputActionEvent_1
// (BlueprintEvent)
// Parameters:
// const struct FInputActionValue&         ActionValue                                            (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor)
// float                                   ElapsedTime                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   TriggeredTime                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class UInputAction*               SourceAction                                           (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::InpActEvt_IP_Thumbstick_Right_K2Node_EnhancedInputActionEvent_1(const struct FInputActionValue& ActionValue, float ElapsedTime, float TriggeredTime, const class UInputAction* SourceAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InpActEvt_IP_Thumbstick_Right_K2Node_EnhancedInputActionEvent_1");

	Params::BP_CombatCharacter_C_InpActEvt_IP_Thumbstick_Right_K2Node_EnhancedInputActionEvent_1 Parms{};

	Parms.ActionValue = std::move(ActionValue);
	Parms.ElapsedTime = ElapsedTime;
	Parms.TriggeredTime = TriggeredTime;
	Parms.SourceAction = SourceAction;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.InputDrawWeapon
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::InputDrawWeapon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InputDrawWeapon");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.InputUIPlayback
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    Input                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::InputUIPlayback(const class FString& Input)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InputUIPlayback");

	Params::BP_CombatCharacter_C_InputUIPlayback Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.interact ladder conduction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::interact_ladder_conduction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "interact ladder conduction");

	Params::BP_CombatCharacter_C_interact_ladder_conduction Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_CameraAnimation
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  FOV                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  BlendTime                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           ControlledActor                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_CameraAnimation(double FOV, double BlendTime, class AActor* ControlledActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_CameraAnimation");

	Params::BP_CombatCharacter_C_Interact_CameraAnimation Parms{};

	Parms.FOV = FOV;
	Parms.BlendTime = BlendTime;
	Parms.ControlledActor = ControlledActor;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_CanInterruptInteraction   
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    CanInterruptInteraction_0                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_CanInterruptInteraction___(bool CanInterruptInteraction_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_CanInterruptInteraction   ");

	Params::BP_CombatCharacter_C_Interact_CanInterruptInteraction___ Parms{};

	Parms.CanInterruptInteraction_0 = CanInterruptInteraction_0;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_CharacterComp
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   IsInteractionCheck                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   IsInterruptInteraction                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   IsSearching                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 CapsuleHalfHeight                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UCameraComponent**                Camera                                                 (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_CharacterComp(bool* IsInteractionCheck, bool* IsInterruptInteraction, bool* IsSearching, double* CapsuleHalfHeight, class UCameraComponent** Camera)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_CharacterComp");

	Params::BP_CombatCharacter_C_Interact_CharacterComp Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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

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

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_EnterLadder
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bottom_side_                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_EnterLadder(bool bottom_side_)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_EnterLadder");

	Params::BP_CombatCharacter_C_Interact_EnterLadder Parms{};

	Parms.bottom_side_ = bottom_side_;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_InteractionObjectArray
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class ABP_InteractionObject_C*>* InteractionObjectArray                                 (Parm, OutParm)

void ABP_CombatCharacter_C::Interact_InteractionObjectArray(TArray<class ABP_InteractionObject_C*>* InteractionObjectArray)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_InteractionObjectArray");

	Params::BP_CombatCharacter_C_Interact_InteractionObjectArray Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_PickupItemsArray
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class ABP_PickupItem_C*>*        InteractionItem_Array_0                                (Parm, OutParm)

void ABP_CombatCharacter_C::Interact_PickupItemsArray(TArray<class ABP_PickupItem_C*>* InteractionItem_Array_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_PickupItemsArray");

	Params::BP_CombatCharacter_C_Interact_PickupItemsArray Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_PlayInteractionAnimation
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             EnumAction                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage**                    Animation                                              (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_PlayInteractionAnimation(class FName EnumAction, class UAnimMontage** Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_PlayInteractionAnimation");

	Params::BP_CombatCharacter_C_Interact_PlayInteractionAnimation Parms{};

	Parms.EnumAction = EnumAction;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_PlayInteractionAnimationByIndex
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   EnumActionIndex                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage**                    Animation                                              (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_PlayInteractionAnimationByIndex(int32 EnumActionIndex, class UAnimMontage** Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_PlayInteractionAnimationByIndex");

	Params::BP_CombatCharacter_C_Interact_PlayInteractionAnimationByIndex Parms{};

	Parms.EnumActionIndex = EnumActionIndex;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_ResetSearchEnd
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Interact_ResetSearchEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_ResetSearchEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetCharacterCollision
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Collide                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    InteractionObject_0                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    door                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Ladder                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetCharacterCollision(bool Collide, bool InteractionObject_0, bool door, bool Ladder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetCharacterCollision");

	Params::BP_CombatCharacter_C_Interact_SetCharacterCollision Parms{};

	Parms.Collide = Collide;
	Parms.InteractionObject_0 = InteractionObject_0;
	Parms.door = door;
	Parms.Ladder = Ladder;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetDoor
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ABP_InteractionDoor_C*            door                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetDoor(class ABP_InteractionDoor_C* door)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetDoor");

	Params::BP_CombatCharacter_C_Interact_SetDoor Parms{};

	Parms.door = door;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetIKLocation
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   IKLocation                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetIKLocation(const struct FVector& IKLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetIKLocation");

	Params::BP_CombatCharacter_C_Interact_SetIKLocation Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetInteractionItemsArray
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const TArray<class ABP_PickupItem_C*>&  InteractionItem_Array_0                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)

void ABP_CombatCharacter_C::Interact_SetInteractionItemsArray(const TArray<class ABP_PickupItem_C*>& InteractionItem_Array_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetInteractionItemsArray");

	Params::BP_CombatCharacter_C_Interact_SetInteractionItemsArray Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetInteractionObjectArray
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const TArray<class ABP_InteractionObject_C*>&InteractionObjectArray                                 (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)

void ABP_CombatCharacter_C::Interact_SetInteractionObjectArray(const TArray<class ABP_InteractionObject_C*>& InteractionObjectArray)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetInteractionObjectArray");

	Params::BP_CombatCharacter_C_Interact_SetInteractionObjectArray Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetIsInteraction
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsInteraction                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetIsInteraction(bool IsInteraction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetIsInteraction");

	Params::BP_CombatCharacter_C_Interact_SetIsInteraction Parms{};

	Parms.IsInteraction = IsInteraction;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetIsPickupItem
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsPickup                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetIsPickupItem(bool IsPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetIsPickupItem");

	Params::BP_CombatCharacter_C_Interact_SetIsPickupItem Parms{};

	Parms.IsPickup = IsPickup;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetIsSearching
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsSearching                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetIsSearching(bool IsSearching)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetIsSearching");

	Params::BP_CombatCharacter_C_Interact_SetIsSearching Parms{};

	Parms.IsSearching = IsSearching;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetLadder
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ABP_InteractionLadder_C*          Ladder                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetLadder(class ABP_InteractionLadder_C* Ladder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetLadder");

	Params::BP_CombatCharacter_C_Interact_SetLadder Parms{};

	Parms.Ladder = Ladder;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetSearchingAnimation
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsSearching                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimSequenceBase*                Animation                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetSearchingAnimation(bool IsSearching, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetSearchingAnimation");

	Params::BP_CombatCharacter_C_Interact_SetSearchingAnimation Parms{};

	Parms.IsSearching = IsSearching;
	Parms.Animation = Animation;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_SetTriggerOverlap
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsTriggerOverlap                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_SetTriggerOverlap(bool IsTriggerOverlap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_SetTriggerOverlap");

	Params::BP_CombatCharacter_C_Interact_SetTriggerOverlap Parms{};

	Parms.IsTriggerOverlap = IsTriggerOverlap;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_StartSnapTargetZ
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USceneComponent*                  SnapZToPoint                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Interact_StartSnapTargetZ(class USceneComponent* SnapZToPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_StartSnapTargetZ");

	Params::BP_CombatCharacter_C_Interact_StartSnapTargetZ Parms{};

	Parms.SnapZToPoint = SnapZToPoint;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_StopSnapTargetZ
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Interact_StopSnapTargetZ()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_StopSnapTargetZ");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interact_TriggerMultiOverlapEndCheck
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Interact_TriggerMultiOverlapEndCheck()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interact_TriggerMultiOverlapEndCheck");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Interaction door conduction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::Interaction_door_conduction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Interaction door conduction");

	Params::BP_CombatCharacter_C_Interaction_door_conduction Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.InteractionSnapTargetZ
// (Private, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::InteractionSnapTargetZ()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InteractionSnapTargetZ");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Internal_PlayAttack
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_MeleeAttackType                       MeleeAttackType                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Duration                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Internal_PlayAttack(E_MeleeAttackType MeleeAttackType, double* Duration, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Internal_PlayAttack");

	Params::BP_CombatCharacter_C_Internal_PlayAttack Parms{};

	Parms.MeleeAttackType = MeleeAttackType;

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.InterruptInteraction
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::InterruptInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "InterruptInteraction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Is Weapon Equipped
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    exclusive_empty_handed                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::Is_Weapon_Equipped(bool exclusive_empty_handed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Is Weapon Equipped");

	Params::BP_CombatCharacter_C_Is_Weapon_Equipped Parms{};

	Parms.exclusive_empty_handed = exclusive_empty_handed;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.IsFalling
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::IsFalling()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IsFalling");

	Params::BP_CombatCharacter_C_IsFalling Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.IsHoldingSprintButton
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   IsSprint                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   RollPressed                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::IsHoldingSprintButton(bool* IsSprint, bool* RollPressed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IsHoldingSprintButton");

	Params::BP_CombatCharacter_C_IsHoldingSprintButton Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.IsLastATK
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_InputBufferKey                        LastAtkType_0                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::IsLastATK(E_InputBufferKey LastAtkType_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IsLastATK");

	Params::BP_CombatCharacter_C_IsLastATK Parms{};

	Parms.LastAtkType_0 = LastAtkType_0;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.IsSprinting
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::IsSprinting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IsSprinting");

	Params::BP_CombatCharacter_C_IsSprinting Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.IsStateEqualTo
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// E_State                                 State                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::IsStateEqualTo(E_State State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IsStateEqualTo");

	Params::BP_CombatCharacter_C_IsStateEqualTo Parms{};

	Parms.State = State;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.IsTargetable
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   return_value                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::IsTargetable(bool* return_value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IsTargetable");

	Params::BP_CombatCharacter_C_IsTargetable Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.IsTargetableByTarget
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           InTarget                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool ABP_CombatCharacter_C::IsTargetableByTarget(class AActor* InTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "IsTargetableByTarget");

	Params::BP_CombatCharacter_C_IsTargetableByTarget Parms{};

	Parms.InTarget = InTarget;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.JumpToHeavyAttackSection
// (Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     Montage                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::JumpToHeavyAttackSection(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "JumpToHeavyAttackSection");

	Params::BP_CombatCharacter_C_JumpToHeavyAttackSection Parms{};

	Parms.Montage = Montage;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.K2_OnBecomeViewTarget
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                PC                                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::K2_OnBecomeViewTarget(class APlayerController* PC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "K2_OnBecomeViewTarget");

	Params::BP_CombatCharacter_C_K2_OnBecomeViewTarget Parms{};

	Parms.PC = PC;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.K2_OnEndViewTarget
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                PC                                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::K2_OnEndViewTarget(class APlayerController* PC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "K2_OnEndViewTarget");

	Params::BP_CombatCharacter_C_K2_OnEndViewTarget Parms{};

	Parms.PC = PC;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.K2_OnMovementModeChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// EMovementMode                           PrevMovementMode                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EMovementMode                           NewMovementMode                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// uint8                                   PrevCustomMode                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// uint8                                   NewCustomMode                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::K2_OnMovementModeChanged(EMovementMode PrevMovementMode, EMovementMode NewMovementMode, uint8 PrevCustomMode, uint8 NewCustomMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "K2_OnMovementModeChanged");

	Params::BP_CombatCharacter_C_K2_OnMovementModeChanged Parms{};

	Parms.PrevMovementMode = PrevMovementMode;
	Parms.NewMovementMode = NewMovementMode;
	Parms.PrevCustomMode = PrevCustomMode;
	Parms.NewCustomMode = NewCustomMode;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.K2_UpdateCustomMovement
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::K2_UpdateCustomMovement(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "K2_UpdateCustomMovement");

	Params::BP_CombatCharacter_C_K2_UpdateCustomMovement Parms{};

	Parms.DeltaTime = DeltaTime;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Land_Uncrouch
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Land_Uncrouch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Land_Uncrouch");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.LastInputVectorNetCache_OnServer
// (Net, NetServer, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector_NetQuantizeNormal& NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::LastInputVectorNetCache_OnServer(const struct FVector_NetQuantizeNormal& NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "LastInputVectorNetCache_OnServer");

	Params::BP_CombatCharacter_C_LastInputVectorNetCache_OnServer Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.LastInputVectorNetCache_RepSet
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   NetValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::LastInputVectorNetCache_RepSet(const struct FVector& NetValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "LastInputVectorNetCache_RepSet");

	Params::BP_CombatCharacter_C_LastInputVectorNetCache_RepSet Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.litfire
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::litfire(bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "litfire");

	Params::BP_CombatCharacter_C_litfire Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.LoopCheckExecuteEvent
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::LoopCheckExecuteEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "LoopCheckExecuteEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.LostEnterDeath
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::LostEnterDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "LostEnterDeath");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.MarkPlayerFirstDeath
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::MarkPlayerFirstDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "MarkPlayerFirstDeath");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.MeleeAttack
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_MeleeAttackType                       Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::MeleeAttack(E_MeleeAttackType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "MeleeAttack");

	Params::BP_CombatCharacter_C_MeleeAttack Parms{};

	Parms.Type = Type;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.montage_time_end
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   MontageInstance                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EMontageDurationEnum                    Duration                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::montage_time_end(int32 MontageInstance, EMontageDurationEnum Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "montage_time_end");

	Params::BP_CombatCharacter_C_montage_time_end Parms{};

	Parms.MontageInstance = MontageInstance;
	Parms.Duration = Duration;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.On Montage Duration
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   MontageInstanceId                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EMontageDurationEnum                    Duration                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::On_Montage_Duration(int32 MontageInstanceId, EMontageDurationEnum Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "On Montage Duration");

	Params::BP_CombatCharacter_C_On_Montage_Duration Parms{};

	Parms.MontageInstanceId = MontageInstanceId;
	Parms.Duration = Duration;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnActiveFlashAttack
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::OnActiveFlashAttack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnActiveFlashAttack");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnActiveItemChanged_Equip
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FF_StoredItem&             OldItem                                                (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// const struct FF_StoredItem&             NewItem                                                (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// E_ItemType                              Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   SlotIndex                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   ActiveIndex                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsSlotChange                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnActiveItemChanged_Equip(const struct FF_StoredItem& OldItem, const struct FF_StoredItem& NewItem, E_ItemType Type, int32 SlotIndex, int32 ActiveIndex, bool IsSlotChange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnActiveItemChanged_Equip");

	Params::BP_CombatCharacter_C_OnActiveItemChanged_Equip Parms{};

	Parms.OldItem = std::move(OldItem);
	Parms.NewItem = std::move(NewItem);
	Parms.Type = Type;
	Parms.SlotIndex = SlotIndex;
	Parms.ActiveIndex = ActiveIndex;
	Parms.IsSlotChange = IsSlotChange;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnCombatCharacterInitComplete
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::OnCombatCharacterInitComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnCombatCharacterInitComplete");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnCombatTypeChanged_Equip
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_CombatType                            CombatType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnCombatTypeChanged_Equip(E_CombatType CombatType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnCombatTypeChanged_Equip");

	Params::BP_CombatCharacter_C_OnCombatTypeChanged_Equip Parms{};

	Parms.CombatType = CombatType;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnDeselected
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   DummyValue                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnDeselected(bool* DummyValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnDeselected");

	Params::BP_CombatCharacter_C_OnDeselected Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnDestroyed_事件_0
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           DestroyedActor                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnDestroyed_事件_0(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnDestroyed_事件_0");

	Params::BP_CombatCharacter_C_OnDestroyed_事件_0 Parms{};

	Parms.DestroyedActor = DestroyedActor;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnEffectApplied_EffectsComp
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         DesiredMontageAction                                   (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)
// class AActor*                           AttackPlayer                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnEffectApplied_EffectsComp(E_EffectType Type, E_MontageAction DesiredMontageAction, int32 Arg0, const struct FVector& ImpactDirection, class AActor* AttackPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnEffectApplied_EffectsComp");

	Params::BP_CombatCharacter_C_OnEffectApplied_EffectsComp Parms{};

	Parms.Type = Type;
	Parms.DesiredMontageAction = DesiredMontageAction;
	Parms.Arg0 = Arg0;
	Parms.ImpactDirection = std::move(ImpactDirection);
	Parms.AttackPlayer = AttackPlayer;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnEffectRemoved_EffectsComp
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_EffectType                            Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   Arg0                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    can_reset_to_idle                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnEffectRemoved_EffectsComp(E_EffectType Type, int32 Arg0, bool can_reset_to_idle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnEffectRemoved_EffectsComp");

	Params::BP_CombatCharacter_C_OnEffectRemoved_EffectsComp Parms{};

	Parms.Type = Type;
	Parms.Arg0 = Arg0;
	Parms.can_reset_to_idle = can_reset_to_idle;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnFirePointSit
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    firepointid                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnFirePointSit(const class FString& firepointid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnFirePointSit");

	Params::BP_CombatCharacter_C_OnFirePointSit Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnFlashAttack
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::OnFlashAttack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnFlashAttack");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnHpChanged
// (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 ABP_CombatCharacter_C::OnHpChanged(const struct FGameplayTag& Type, double OldValue, double NewValue, double MaxValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnHpChanged");

	Params::BP_CombatCharacter_C_OnHpChanged Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnInCombatChanged_Equip
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsInCombat                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnInCombatChanged_Equip(bool IsInCombat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnInCombatChanged_Equip");

	Params::BP_CombatCharacter_C_OnInCombatChanged_Equip Parms{};

	Parms.IsInCombat = IsInCombat;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnInputRollAction
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Triggered                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnInputRollAction(bool Triggered)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnInputRollAction");

	Params::BP_CombatCharacter_C_OnInputRollAction Parms{};

	Parms.Triggered = Triggered;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnInputSprintAction
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Triggered                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnInputSprintAction(bool Triggered)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnInputSprintAction");

	Params::BP_CombatCharacter_C_OnInputSprintAction Parms{};

	Parms.Triggered = Triggered;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnLevelLoadFinished
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::OnLevelLoadFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnLevelLoadFinished");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnMainHandTypeChanged_Equip
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_ItemType                              Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnMainHandTypeChanged_Equip(E_ItemType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnMainHandTypeChanged_Equip");

	Params::BP_CombatCharacter_C_OnMainHandTypeChanged_Equip Parms{};

	Parms.Type = Type;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnPlayerHasBorned_Event
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    FirePoint                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool                                    isReborn                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FTransform&                Position                                               (BlueprintVisible, BlueprintReadOnly, Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnPlayerHasBorned_Event(const class FString& FirePoint, bool isReborn, const struct FTransform& Position)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnPlayerHasBorned_Event");

	Params::BP_CombatCharacter_C_OnPlayerHasBorned_Event Parms{};

	Parms.FirePoint = std::move(FirePoint);
	Parms.isReborn = isReborn;
	Parms.Position = std::move(Position);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnPlayerIntPropertyChanged
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              Property                                               (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// int32                                   OldIntValue                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   NewIntValue                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnPlayerIntPropertyChanged(const struct FGameplayTag& Property, int32 OldIntValue, int32 NewIntValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnPlayerIntPropertyChanged");

	Params::BP_CombatCharacter_C_OnPlayerIntPropertyChanged Parms{};

	Parms.Property = std::move(Property);
	Parms.OldIntValue = OldIntValue;
	Parms.NewIntValue = NewIntValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnRotateEnd_RotateComp
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::OnRotateEnd_RotateComp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnRotateEnd_RotateComp");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnSelected
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   SocketIndex                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   DummyValue                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnSelected(int32 SocketIndex, bool* DummyValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnSelected");

	Params::BP_CombatCharacter_C_OnSelected Parms{};

	Parms.SocketIndex = SocketIndex;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnSettingValueChanged
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              OptionTag                                              (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnSettingValueChanged(const struct FGameplayTag& OptionTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnSettingValueChanged");

	Params::BP_CombatCharacter_C_OnSettingValueChanged Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnStateChanged
// (Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    prevName                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    prevState                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    currName                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    currState                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnStateChanged(const class FString& prevName, const class FString& prevState, const class FString& currName, const class FString& currState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnStateChanged");

	Params::BP_CombatCharacter_C_OnStateChanged Parms{};

	Parms.prevName = std::move(prevName);
	Parms.prevState = std::move(prevState);
	Parms.currName = std::move(currName);
	Parms.currState = std::move(currState);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnStateChanged_StateManagerComp
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_State                                 prevState                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_State                                 NewState                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnStateChanged_StateManagerComp(E_State prevState, E_State NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnStateChanged_StateManagerComp");

	Params::BP_CombatCharacter_C_OnStateChanged_StateManagerComp Parms{};

	Parms.prevState = prevState;
	Parms.NewState = NewState;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnUINumNotify
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Number                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OnUINumNotify(int32 Number)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnUINumNotify");

	Params::BP_CombatCharacter_C_OnUINumNotify Parms{};

	Parms.Number = Number;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OnValueChanged_Stamina
// (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 ABP_CombatCharacter_C::OnValueChanged_Stamina(const struct FGameplayTag& Type, double OldValue, double NewValue, double MaxValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OnValueChanged_Stamina");

	Params::BP_CombatCharacter_C_OnValueChanged_Stamina Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.OpenBloodScreen
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::OpenBloodScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OpenBloodScreen");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.OpenedUI
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::OpenedUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OpenedUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.OverrideTargetingTraceEndLocation
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Override                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector*                         Location                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::OverrideTargetingTraceEndLocation(bool* Override, struct FVector* Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "OverrideTargetingTraceEndLocation");

	Params::BP_CombatCharacter_C_OverrideTargetingTraceEndLocation Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlayAndUseItem
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   SortID                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    UseCurrentFast                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::PlayAndUseItem(int32 SortID, int32 Amount, bool UseCurrentFast)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlayAndUseItem");

	Params::BP_CombatCharacter_C_PlayAndUseItem Parms{};

	Parms.SortID = SortID;
	Parms.Amount = Amount;
	Parms.UseCurrentFast = UseCurrentFast;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlayerHideFace
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    NeedHide                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   NewParam                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::PlayerHideFace(bool NeedHide, bool* NewParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlayerHideFace");

	Params::BP_CombatCharacter_C_PlayerHideFace Parms{};

	Parms.NeedHide = NeedHide;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlayerPropertyChanged
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              Property                                               (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, HasGetValueTypeHash)
// double                                  OldValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::PlayerPropertyChanged(const struct FGameplayTag& Property, double OldValue, double NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlayerPropertyChanged");

	Params::BP_CombatCharacter_C_PlayerPropertyChanged Parms{};

	Parms.Property = std::move(Property);
	Parms.OldValue = OldValue;
	Parms.NewValue = NewValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlayMainHandTypeChangedMontage
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_ItemType                              Type                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IgnoreCombatType                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsSlotChange                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::PlayMainHandTypeChangedMontage(E_ItemType Type, bool IgnoreCombatType, bool IsSlotChange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlayMainHandTypeChangedMontage");

	Params::BP_CombatCharacter_C_PlayMainHandTypeChangedMontage Parms{};

	Parms.Type = Type;
	Parms.IgnoreCombatType = IgnoreCombatType;
	Parms.IsSlotChange = IsSlotChange;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlayMontage
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// float                                   InPlayRate                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             StartSectionName                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

float ABP_CombatCharacter_C::PlayMontage(class UAnimMontage* AnimMontage, float InPlayRate, class FName StartSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlayMontage");

	Params::BP_CombatCharacter_C_PlayMontage Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.InPlayRate = InPlayRate;
	Parms.StartSectionName = StartSectionName;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlayPickupAnim
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::PlayPickupAnim()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlayPickupAnim");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlaySitDown
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::PlaySitDown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlaySitDown");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.PlaySpecialEffect
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Mode                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::PlaySpecialEffect(int32 Mode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "PlaySpecialEffect");

	Params::BP_CombatCharacter_C_PlaySpecialEffect Parms{};

	Parms.Mode = Mode;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Private_TickMovedirection
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Private_TickMovedirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Private_TickMovedirection");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.reborn
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::reborn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "reborn");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ReceiveTick
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaSeconds                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ReceiveTick(float DeltaSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ReceiveTick");

	Params::BP_CombatCharacter_C_ReceiveTick Parms{};

	Parms.DeltaSeconds = DeltaSeconds;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.RefreshAirBlock
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::RefreshAirBlock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "RefreshAirBlock");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.RefreshingStatusToMaximumValue
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::RefreshingStatusToMaximumValue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "RefreshingStatusToMaximumValue");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ReleaseActionKey
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_InputBufferKey                        ActioinKey                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ReleaseActionKey(E_InputBufferKey ActioinKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ReleaseActionKey");

	Params::BP_CombatCharacter_C_ReleaseActionKey Parms{};

	Parms.ActioinKey = ActioinKey;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ReleaseAlertUIOnPlayer
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Enemy                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class USceneComponent*                  alertBar                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ReleaseAlertUIOnPlayer(class AActor* Enemy, class USceneComponent* alertBar)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ReleaseAlertUIOnPlayer");

	Params::BP_CombatCharacter_C_ReleaseAlertUIOnPlayer Parms{};

	Parms.Enemy = Enemy;
	Parms.alertBar = alertBar;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.RemoveAccessActivity
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const EDCSActivityType                  RemoveAct                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::RemoveAccessActivity(const EDCSActivityType RemoveAct)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "RemoveAccessActivity");

	Params::BP_CombatCharacter_C_RemoveAccessActivity Parms{};

	Parms.RemoveAct = RemoveAct;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.RemoveShapeMesh
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USkeletalMeshComponent*           SkeletalMeshComponent                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool*                                   Temp                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::RemoveShapeMesh(class USkeletalMeshComponent* SkeletalMeshComponent, bool* Temp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "RemoveShapeMesh");

	Params::BP_CombatCharacter_C_RemoveShapeMesh Parms{};

	Parms.SkeletalMeshComponent = SkeletalMeshComponent;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.RequestAlertUIOnPlayer
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Enemy                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class USceneComponent*                  alertBar                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class UUserWidget**                     alertUI                                                (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::RequestAlertUIOnPlayer(class AActor* Enemy, class USceneComponent* alertBar, class UUserWidget** alertUI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "RequestAlertUIOnPlayer");

	Params::BP_CombatCharacter_C_RequestAlertUIOnPlayer Parms{};

	Parms.Enemy = Enemy;
	Parms.alertBar = alertBar;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.RequestSlowInMontage
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    slow                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   MontageInstanceId                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::RequestSlowInMontage(bool slow, int32 MontageInstanceId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "RequestSlowInMontage");

	Params::BP_CombatCharacter_C_RequestSlowInMontage Parms{};

	Parms.slow = slow;
	Parms.MontageInstanceId = MontageInstanceId;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetActionEventValue
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ResetActionEventValue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetActionEventValue");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetAimingMode
// (Private, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ResetAimingMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetAimingMode");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetCanIterruptInteraction
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ResetCanIterruptInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetCanIterruptInteraction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetChangeSpellBS
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   MontageInstance                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EMontageDurationEnum                    Duration                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ResetChangeSpellBS(int32 MontageInstance, EMontageDurationEnum Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetChangeSpellBS");

	Params::BP_CombatCharacter_C_ResetChangeSpellBS Parms{};

	Parms.MontageInstance = MontageInstance;
	Parms.Duration = Duration;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetFromSit
// (Private, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ResetFromSit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetFromSit");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetInteractionTriggerInterval
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ResetInteractionTriggerInterval()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetInteractionTriggerInterval");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetMeleeAttackCounterByBreakFlagStarActive
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_InputBufferBreakFlag                  BreakFlag                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ResetMeleeAttackCounterByBreakFlagStarActive(E_InputBufferBreakFlag BreakFlag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetMeleeAttackCounterByBreakFlagStarActive");

	Params::BP_CombatCharacter_C_ResetMeleeAttackCounterByBreakFlagStarActive Parms{};

	Parms.BreakFlag = BreakFlag;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetStartMontageMontage
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// E_State                                 NewActionState                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         MontageAction_0                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAnimMontage*                     PlayingMontage                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ResetStartMontageMontage(E_State NewActionState, E_MontageAction MontageAction_0, class UAnimMontage* PlayingMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetStartMontageMontage");

	Params::BP_CombatCharacter_C_ResetStartMontageMontage Parms{};

	Parms.NewActionState = NewActionState;
	Parms.MontageAction_0 = MontageAction_0;
	Parms.PlayingMontage = PlayingMontage;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ResetValueWhenStateChanges_Override
// (Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    NewStateName                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// E_State                                 NewState                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ResetValueWhenStateChanges_Override(const class FString& NewStateName, E_State NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ResetValueWhenStateChanges_Override");

	Params::BP_CombatCharacter_C_ResetValueWhenStateChanges_Override Parms{};

	Parms.NewStateName = std::move(NewStateName);
	Parms.NewState = NewState;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ReverseMeleeAttackCounter
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ReverseMeleeAttackCounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ReverseMeleeAttackCounter");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.roll
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::roll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "roll");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.RollAction
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::RollAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "RollAction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.SelectNearestItem
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class ABP_PickupItem_C**                Pick_Item                                              (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SelectNearestItem(class ABP_PickupItem_C** Pick_Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SelectNearestItem");

	Params::BP_CombatCharacter_C_SelectNearestItem Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.SelectNearestObject
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class ABP_InteractionObject_C**         InteractionObject_0                                    (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SelectNearestObject(class ABP_InteractionObject_C** InteractionObject_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SelectNearestObject");

	Params::BP_CombatCharacter_C_SelectNearestObject Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Set Camera Lag Smoothly
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  TargetLagSpeed_0                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  TargetRotateLagSpeed                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Set_Camera_Lag_Smoothly(double TargetLagSpeed_0, double TargetRotateLagSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Set Camera Lag Smoothly");

	Params::BP_CombatCharacter_C_Set_Camera_Lag_Smoothly Parms{};

	Parms.TargetLagSpeed_0 = TargetLagSpeed_0;
	Parms.TargetRotateLagSpeed = TargetRotateLagSpeed;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetCameraLag Timer__FinishedFunc
// (BlueprintEvent)

void ABP_CombatCharacter_C::SetCameraLag_Timer__FinishedFunc()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetCameraLag Timer__FinishedFunc");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetCameraLag Timer__UpdateFunc
// (BlueprintEvent)

void ABP_CombatCharacter_C::SetCameraLag_Timer__UpdateFunc()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetCameraLag Timer__UpdateFunc");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetCameraLagValue
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    fast_                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SetCameraLagValue(bool fast_)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetCameraLagValue");

	Params::BP_CombatCharacter_C_SetCameraLagValue Parms{};

	Parms.fast_ = fast_;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetCameraMeshSocketFollow
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bEnable                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             SocketName                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SetCameraMeshSocketFollow(bool bEnable, class FName SocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetCameraMeshSocketFollow");

	Params::BP_CombatCharacter_C_SetCameraMeshSocketFollow Parms{};

	Parms.bEnable = bEnable;
	Parms.SocketName = SocketName;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetExecuteCheckedSource
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Add                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class AAbstractCharacter_C*&      Source                                                 (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SetExecuteCheckedSource(bool Add, const class AAbstractCharacter_C*& Source)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetExecuteCheckedSource");

	Params::BP_CombatCharacter_C_SetExecuteCheckedSource Parms{};

	Parms.Add = Add;
	Parms.Source = Source;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetKeepUseItem
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Value                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SetKeepUseItem(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetKeepUseItem");

	Params::BP_CombatCharacter_C_SetKeepUseItem Parms{};

	Parms.Value = Value;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetSpotParam
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  NewIntensity                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  NewTemperature                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  LightsActor                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  VSI_Intensity                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  DL_Player                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  DL_AINPC                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SetSpotParam(double NewIntensity, double NewTemperature, double LightsActor, double VSI_Intensity, double DL_Player, double DL_AINPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetSpotParam");

	Params::BP_CombatCharacter_C_SetSpotParam Parms{};

	Parms.NewIntensity = NewIntensity;
	Parms.NewTemperature = NewTemperature;
	Parms.LightsActor = LightsActor;
	Parms.VSI_Intensity = VSI_Intensity;
	Parms.DL_Player = DL_Player;
	Parms.DL_AINPC = DL_AINPC;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.SetSprint
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Activate                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::SetSprint(bool Activate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "SetSprint");

	Params::BP_CombatCharacter_C_SetSprint Parms{};

	Parms.Activate = Activate;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ShowCrosshair
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UTexture2D*                       Texture                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::ShowCrosshair(class UTexture2D* Texture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ShowCrosshair");

	Params::BP_CombatCharacter_C_ShowCrosshair Parms{};

	Parms.Texture = Texture;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ShowDeathUI
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ShowDeathUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ShowDeathUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.showGameUI
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Show                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::showGameUI(bool Show)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "showGameUI");

	Params::BP_CombatCharacter_C_showGameUI Parms{};

	Parms.Show = Show;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.showPlayerSelf
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::showPlayerSelf()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "showPlayerSelf");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.slowdown
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::slowdown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "slowdown");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StartAiming
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StartAiming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StartAiming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StartBlocking
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StartBlocking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StartBlocking");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StartDelayShowGameUI
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StartDelayShowGameUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StartDelayShowGameUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StartLookingForward
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StartLookingForward()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StartLookingForward");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StartZooming
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StartZooming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StartZooming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Stop_CameraAnimation
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  BlendTime                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           ControlledActor                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Stop_CameraAnimation(double BlendTime, class AActor* ControlledActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Stop_CameraAnimation");

	Params::BP_CombatCharacter_C_Stop_CameraAnimation Parms{};

	Parms.BlendTime = BlendTime;
	Parms.ControlledActor = ControlledActor;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.StopAiming
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StopAiming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StopAiming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StopBlocking
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StopBlocking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StopBlocking");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StopLookingForward
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StopLookingForward()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StopLookingForward");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.StopZooming
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::StopZooming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "StopZooming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Sync_JumpToHeavyAttackSection
// (Net, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     Montage                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Sync_JumpToHeavyAttackSection(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Sync_JumpToHeavyAttackSection");

	Params::BP_CombatCharacter_C_Sync_JumpToHeavyAttackSection Parms{};

	Parms.Montage = Montage;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Sync_StopAnimMontage
// (Net, NetMulticast, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Sync_StopAnimMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Sync_StopAnimMontage");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Sync_StopMongtage
// (Net, NetMulticast, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UAnimMontage*               Montage                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Sync_StopMongtage(const class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Sync_StopMongtage");

	Params::BP_CombatCharacter_C_Sync_StopMongtage Parms{};

	Parms.Montage = Montage;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.TickUpdateSpeedAndNoise
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::TickUpdateSpeedAndNoise()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "TickUpdateSpeedAndNoise");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Toggle Combat
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double*                                 animation_duration                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Toggle_Combat(double* animation_duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Toggle Combat");

	Params::BP_CombatCharacter_C_Toggle_Combat Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ToggleTargetting
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::ToggleTargetting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "ToggleTargetting");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Try Get Fixed Target Location
// (Private, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AActor*                           Target                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FVector*                         FixedLocation                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Try_Get_Fixed_Target_Location(class AActor* Target, struct FVector* FixedLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Try Get Fixed Target Location");

	Params::BP_CombatCharacter_C_Try_Get_Fixed_Target_Location Parms{};

	Parms.Target = Target;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UnequipExecuteWeapon
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UnequipExecuteWeapon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UnequipExecuteWeapon");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Update Camera Lag
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Update_Camera_Lag()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Update Camera Lag");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Update Input Key
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_InputBufferKey                        Key                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::Update_Input_Key(E_InputBufferKey Key)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Update Input Key");

	Params::BP_CombatCharacter_C_Update_Input_Key Parms{};

	Parms.Key = Key;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.update ladder movement
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::update_ladder_movement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "update ladder movement");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.update rollup movement
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::update_rollup_movement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "update rollup movement");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.update rootmotion movement
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::update_rootmotion_movement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "update rootmotion movement");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Update Sprint Stat
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Update_Sprint_Stat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Update Sprint Stat");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateAimAlpha
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UpdateAimAlpha()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateAimAlpha");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateBlocking
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UpdateBlocking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateBlocking");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateCachedRollDirection
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   Velocity                                               (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction*                        OutRollDirection                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::UpdateCachedRollDirection(const struct FVector& Velocity, E_MontageAction* OutRollDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateCachedRollDirection");

	Params::BP_CombatCharacter_C_UpdateCachedRollDirection Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateCanPlayMoveStartMontage
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    Can                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::UpdateCanPlayMoveStartMontage(bool Can)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateCanPlayMoveStartMontage");

	Params::BP_CombatCharacter_C_UpdateCanPlayMoveStartMontage Parms{};

	Parms.Can = Can;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateFallDownRollDirection
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UpdateFallDownRollDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateFallDownRollDirection");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateHorizontalLook
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  AxisValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::UpdateHorizontalLook(double AxisValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateHorizontalLook");

	Params::BP_CombatCharacter_C_UpdateHorizontalLook Parms{};

	Parms.AxisValue = AxisValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateInteractTrace
// (Protected, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UpdateInteractTrace()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateInteractTrace");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateLadderUp
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  AxisValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::UpdateLadderUp(double AxisValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateLadderUp");

	Params::BP_CombatCharacter_C_UpdateLadderUp Parms{};

	Parms.AxisValue = AxisValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateMoveForward
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  AxisValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::UpdateMoveForward(double AxisValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateMoveForward");

	Params::BP_CombatCharacter_C_UpdateMoveForward Parms{};

	Parms.AxisValue = AxisValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateMoveRight
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  AxisValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::UpdateMoveRight(double AxisValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateMoveRight");

	Params::BP_CombatCharacter_C_UpdateMoveRight Parms{};

	Parms.AxisValue = AxisValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateRotationSettings
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UpdateRotationSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateRotationSettings");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateVerticalLook
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  AxisValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::UpdateVerticalLook(double AxisValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateVerticalLook");

	Params::BP_CombatCharacter_C_UpdateVerticalLook Parms{};

	Parms.AxisValue = AxisValue;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.UpdateZoom
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UpdateZoom()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UpdateZoom");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.UserConstructionScript
// (Event, Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::UserConstructionScript()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "UserConstructionScript");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.WeaponSkillWithID
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const int32                             SkillID                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// E_MontageAction                         Action                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Succeed                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::WeaponSkillWithID(const int32 SkillID, E_MontageAction Action, bool* Succeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "WeaponSkillWithID");

	Params::BP_CombatCharacter_C_WeaponSkillWithID Parms{};

	Parms.SkillID = SkillID;
	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.WhosyourBigDaddy
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::WhosyourBigDaddy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "WhosyourBigDaddy");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Whosyourdaddy
// (BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::Whosyourdaddy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Whosyourdaddy");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.YawViewOut
// (Public, BlueprintCallable, BlueprintEvent)

void ABP_CombatCharacter_C::YawViewOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "YawViewOut");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Zooming_Timeline__FinishedFunc
// (BlueprintEvent)

void ABP_CombatCharacter_C::Zooming_Timeline__FinishedFunc()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Zooming_Timeline__FinishedFunc");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.Zooming_Timeline__UpdateFunc
// (BlueprintEvent)

void ABP_CombatCharacter_C::Zooming_Timeline__UpdateFunc()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "Zooming_Timeline__UpdateFunc");

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.BindEvents
// (BlueprintCallable, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


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

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

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

	Params::BP_CombatCharacter_C_Can_Flash_Attack Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.death_1
// (Public, BlueprintCallable, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.death_2
// (Public, BlueprintCallable, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


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

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

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

	Params::BP_CombatCharacter_C_EnterDeath Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


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

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

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

	Params::BP_CombatCharacter_C_GetBackAttackFactor Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_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 ABP_CombatCharacter_C::GetDeathEffectCurve(class UAnimMontage* DeathMontage, class UCurveFloat** Vanish)
{
	static class UFunction* Func = nullptr;

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

	Params::BP_CombatCharacter_C_GetDeathEffectCurve Parms{};

	Parms.DeathMontage = DeathMontage;

	UObject::ProcessEvent(Func, &Parms);

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


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

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

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

	Params::BP_CombatCharacter_C_GetDesiredFollowRotation Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_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 ABP_CombatCharacter_C::GetDesiredRotation(bool Refresh, int32 rotateIntent, struct FRotator* Rotation)
{
	static class UFunction* Func = nullptr;

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

	Params::BP_CombatCharacter_C_GetDesiredRotation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

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


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

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

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

	Params::BP_CombatCharacter_C_getLadderPosition Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


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

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

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

	Params::BP_CombatCharacter_C_GetMontages Parms{};

	Parms.Action = Action;

	UObject::ProcessEvent(Func, &Parms);

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


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

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

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

	Params::BP_CombatCharacter_C_GetMyForceActing Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


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

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

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

	Params::BP_CombatCharacter_C_GetNetworkState Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


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

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

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

	Params::BP_CombatCharacter_C_GetState Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


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

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

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

	Params::BP_CombatCharacter_C_ImplBufferInput Parms{};

	Parms.InAction = InAction;

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


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

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

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

	Params::BP_CombatCharacter_C_ImplFallendamageBufferInput Parms{};

	Parms.InAction = InAction;

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


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

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

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

	Params::BP_CombatCharacter_C_ImplHoldActioninput Parms{};

	Parms.InAction = InAction;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.ImplInputInteract
// (Event, Public, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_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 ABP_CombatCharacter_C::ImplPrintPoint(const class FString& StateName, const class FString& EventName)
{
	static class UFunction* Func = nullptr;

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

	Params::BP_CombatCharacter_C_ImplPrintPoint Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ImplTakeDamage
// (Event, Public, HasOutParams, 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 ABP_CombatCharacter_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("BP_CombatCharacter_C", "ImplTakeDamage");

	Params::BP_CombatCharacter_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 BP_CombatCharacter.BP_CombatCharacter_C.ImplTickMove
// (Event, Public, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ImplTryBreakInteract
// (Event, Public, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ImplTryEndRebornfire
// (Event, Public, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ImplUpdateForwardmove
// (Event, Public, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


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

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

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

	Params::BP_CombatCharacter_C_ImplWeaponLoopBufferInput Parms{};

	Parms.InAction = InAction;

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


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

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

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

	Params::BP_CombatCharacter_C_ImplWeaponLoopInputWithCheck Parms{};

	Parms.InAction = InAction;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.InternalMontageAction
// (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)
// 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 ABP_CombatCharacter_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("BP_CombatCharacter_C", "InternalMontageAction");

	Params::BP_CombatCharacter_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 BP_CombatCharacter.BP_CombatCharacter_C.IsAlive
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   Result                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

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

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

	Params::BP_CombatCharacter_C_IsAlive Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


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

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

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

	Params::BP_CombatCharacter_C_JumpToSection Parms{};

	Parms.SectionName = SectionName;

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


// Function BP_CombatCharacter.BP_CombatCharacter_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 ABP_CombatCharacter_C::OnActivityChanged_StateManagerComp(E_Activity Activity, bool Value)
{
	static class UFunction* Func = nullptr;

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

	Params::BP_CombatCharacter_C_OnActivityChanged_StateManagerComp Parms{};

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

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


// Function BP_CombatCharacter.BP_CombatCharacter_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 ABP_CombatCharacter_C::OnValueChanged_Health(const struct FGameplayTag& Type, double OldValue, double NewValue, double MaxValue)
{
	static class UFunction* Func = nullptr;

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

	Params::BP_CombatCharacter_C_OnValueChanged_Health Parms{};

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

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


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

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

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

	Params::BP_CombatCharacter_C_Play_Counter_Attack Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.Private_TakeDamage
// (Protected, HasOutParams, 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 ABP_CombatCharacter_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("BP_CombatCharacter_C", "Private_TakeDamage");

	Params::BP_CombatCharacter_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 BP_CombatCharacter.BP_CombatCharacter_C.ReceiveBeginPlay
// (Event, Protected, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


// Function BP_CombatCharacter.BP_CombatCharacter_C.ReceiveDestroyed
// (Event, Public, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


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

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

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

	Params::BP_CombatCharacter_C_ResetIdleState Parms{};

	Parms.Delay = Delay;

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


// Function BP_CombatCharacter.BP_CombatCharacter_C.TakeDamage
// (Public, HasOutParams, 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 ABP_CombatCharacter_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("BP_CombatCharacter_C", "TakeDamage");

	Params::BP_CombatCharacter_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 BP_CombatCharacter.BP_CombatCharacter_C.GetPlayerSpeed
// (Protected, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UImplMovementSpeed_Player_C**     PlayerSpeed                                            (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void ABP_CombatCharacter_C::GetPlayerSpeed(class UImplMovementSpeed_Player_C** PlayerSpeed) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BP_CombatCharacter_C", "GetPlayerSpeed");

	Params::BP_CombatCharacter_C_GetPlayerSpeed Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

}