ReshadePluginsCore/ClairObscur/SDK/AC_jRPG_CharacterBattleStats_functions.cpp

#pragma once

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

// Package: AC_jRPG_CharacterBattleStats

#include "Basic.hpp"

#include "AC_jRPG_CharacterBattleStats_classes.hpp"
#include "AC_jRPG_CharacterBattleStats_parameters.hpp"


namespace SDK
{

// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetDamageSourceCharacter
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C** CharacterStats_0                                       (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetDamageSourceCharacter(class UAC_jRPG_CharacterBattleStats_C** CharacterStats_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetDamageSourceCharacter");

	Params::AC_jRPG_CharacterBattleStats_C_GetDamageSourceCharacter Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetDamageSourceType
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// EDamageReason*                          DamageSourceType                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetDamageSourceType(EDamageReason* DamageSourceType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetDamageSourceType");

	Params::AC_jRPG_CharacterBattleStats_C_GetDamageSourceType Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.NotifySkillStatesAvailable
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::NotifySkillStatesAvailable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "NotifySkillStatesAvailable");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CanCounterAttackCurrentEnemySkill
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::CanCounterAttackCurrentEnemySkill()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CanCounterAttackCurrentEnemySkill");

	Params::AC_jRPG_CharacterBattleStats_C_CanCounterAttackCurrentEnemySkill Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsDeathQueuedForTurnEnd
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsDeathQueuedForTurnEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsDeathQueuedForTurnEnd");

	Params::AC_jRPG_CharacterBattleStats_C_IsDeathQueuedForTurnEnd Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ClearSkillStates
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::ClearSkillStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ClearSkillStates");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetDead_Internal
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::SetDead_Internal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetDead_Internal");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsPreparedForBattle
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsPreparedForBattle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsPreparedForBattle");

	Params::AC_jRPG_CharacterBattleStats_C_IsPreparedForBattle Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetGenderTag
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// ETextGender                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

ETextGender UAC_jRPG_CharacterBattleStats_C::GetGenderTag()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetGenderTag");

	Params::AC_jRPG_CharacterBattleStats_C_GetGenderTag Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.TryDodgeHitFromCharacter
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  AttackingCharacter                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool*                                   Successful                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   IsPerfectDodge                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::TryDodgeHitFromCharacter(class UAC_jRPG_CharacterBattleStats_C* AttackingCharacter, bool* Successful, bool* IsPerfectDodge)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "TryDodgeHitFromCharacter");

	Params::AC_jRPG_CharacterBattleStats_C_TryDodgeHitFromCharacter Parms{};

	Parms.AttackingCharacter = AttackingCharacter;

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.TryParryHitFromCharacter
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  AttackingCharacter                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool*                                   Successful                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::TryParryHitFromCharacter(class UAC_jRPG_CharacterBattleStats_C* AttackingCharacter, bool* Successful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "TryParryHitFromCharacter");

	Params::AC_jRPG_CharacterBattleStats_C_TryParryHitFromCharacter Parms{};

	Parms.AttackingCharacter = AttackingCharacter;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetParryWindowModifier
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UModifierStack_Float**            Stack                                                  (Parm, OutParm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetParryWindowModifier(class UModifierStack_Float** Stack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetParryWindowModifier");

	Params::AC_jRPG_CharacterBattleStats_C_GetParryWindowModifier Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveParryWindowModifier
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ModifierStackEntryHandle&    OutModifierHandle                                      (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)

void UAC_jRPG_CharacterBattleStats_C::RemoveParryWindowModifier(struct FSF_ModifierStackEntryHandle& OutModifierHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveParryWindowModifier");

	Params::AC_jRPG_CharacterBattleStats_C_RemoveParryWindowModifier Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	OutModifierHandle = std::move(Parms.OutModifierHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddParryWindowModifier
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Percent                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FSF_ModifierStackEntryHandle&    OutModifierHandle                                      (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// const class FString&                    DebugName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddParryWindowModifier(double Percent, struct FSF_ModifierStackEntryHandle& OutModifierHandle, const class FString& DebugName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddParryWindowModifier");

	Params::AC_jRPG_CharacterBattleStats_C_AddParryWindowModifier Parms{};

	Parms.Percent = Percent;
	Parms.OutModifierHandle = std::move(OutModifierHandle);
	Parms.DebugName = std::move(DebugName);

	UObject::ProcessEvent(Func, &Parms);

	OutModifierHandle = std::move(Parms.OutModifierHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetDodgeWindowModifier
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UModifierStack_Float**            Stack                                                  (Parm, OutParm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetDodgeWindowModifier(class UModifierStack_Float** Stack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetDodgeWindowModifier");

	Params::AC_jRPG_CharacterBattleStats_C_GetDodgeWindowModifier Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveDodgeWindowModifier
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ModifierStackEntryHandle&    OutModifierHandle                                      (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)

void UAC_jRPG_CharacterBattleStats_C::RemoveDodgeWindowModifier(struct FSF_ModifierStackEntryHandle& OutModifierHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveDodgeWindowModifier");

	Params::AC_jRPG_CharacterBattleStats_C_RemoveDodgeWindowModifier Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	OutModifierHandle = std::move(Parms.OutModifierHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddDodgeWindowModifier
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Percent                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FSF_ModifierStackEntryHandle&    OutModifierHandle                                      (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// const class FString&                    DebugName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddDodgeWindowModifier(double Percent, struct FSF_ModifierStackEntryHandle& OutModifierHandle, const class FString& DebugName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddDodgeWindowModifier");

	Params::AC_jRPG_CharacterBattleStats_C_AddDodgeWindowModifier Parms{};

	Parms.Percent = Percent;
	Parms.OutModifierHandle = std::move(OutModifierHandle);
	Parms.DebugName = std::move(DebugName);

	UObject::ProcessEvent(Func, &Parms);

	OutModifierHandle = std::move(Parms.OutModifierHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveParryLock
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ReferenceCounterHandle&      LockHandle                                             (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)

void UAC_jRPG_CharacterBattleStats_C::RemoveParryLock(struct FSF_ReferenceCounterHandle& LockHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveParryLock");

	Params::AC_jRPG_CharacterBattleStats_C_RemoveParryLock Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	LockHandle = std::move(Parms.LockHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddParryLock
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ReferenceCounterHandle&      LockHandle                                             (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// const class FString&                    DebugReason                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddParryLock(struct FSF_ReferenceCounterHandle& LockHandle, const class FString& DebugReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddParryLock");

	Params::AC_jRPG_CharacterBattleStats_C_AddParryLock Parms{};

	Parms.LockHandle = std::move(LockHandle);
	Parms.DebugReason = std::move(DebugReason);

	UObject::ProcessEvent(Func, &Parms);

	LockHandle = std::move(Parms.LockHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsParryLocked
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsParryLocked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsParryLocked");

	Params::AC_jRPG_CharacterBattleStats_C_IsParryLocked Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentSkillScript
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class ABP_Battle_SkillScript_C*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash)

class ABP_Battle_SkillScript_C* UAC_jRPG_CharacterBattleStats_C::GetCurrentSkillScript()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentSkillScript");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentSkillScript Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsOfArchetype
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// TSoftObjectPtr<class UBP_DataAsset_EnemyBattleArchetype_C>Archetype                                              (BlueprintVisible, BlueprintReadOnly, Parm, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsOfArchetype(TSoftObjectPtr<class UBP_DataAsset_EnemyBattleArchetype_C> Archetype)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsOfArchetype");

	Params::AC_jRPG_CharacterBattleStats_C_IsOfArchetype Parms{};

	Parms.Archetype = Archetype;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetArchetype
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UBP_DataAsset_EnemyBattleArchetype_C**Archetype                                              (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetArchetype(class UBP_DataAsset_EnemyBattleArchetype_C** Archetype)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetArchetype");

	Params::AC_jRPG_CharacterBattleStats_C_GetArchetype Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ResetCurrentParryFlags
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::ResetCurrentParryFlags()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ResetCurrentParryFlags");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ResetCurrentAttackTypeFlags
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::ResetCurrentAttackTypeFlags()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ResetCurrentAttackTypeFlags");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetForcedSkillOnNextTurn
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class ABP_Battle_SkillScript_C*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash)

class ABP_Battle_SkillScript_C* UAC_jRPG_CharacterBattleStats_C::GetForcedSkillOnNextTurn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetForcedSkillOnNextTurn");

	Params::AC_jRPG_CharacterBattleStats_C_GetForcedSkillOnNextTurn Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.TryProcessForcedSkill
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool*                                   PreventPlayerChoice                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::TryProcessForcedSkill(bool* PreventPlayerChoice)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "TryProcessForcedSkill");

	Params::AC_jRPG_CharacterBattleStats_C_TryProcessForcedSkill Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ForceSkillOnNextTurn
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ABP_Battle_SkillScript_C*         SkillScript                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ForceSkillOnNextTurn(class ABP_Battle_SkillScript_C* SkillScript)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ForceSkillOnNextTurn");

	Params::AC_jRPG_CharacterBattleStats_C_ForceSkillOnNextTurn Parms{};

	Parms.SkillScript = SkillScript;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsSameCharacterStats
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  CharacterStats_0                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsSameCharacterStats(class UAC_jRPG_CharacterBattleStats_C* CharacterStats_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsSameCharacterStats");

	Params::AC_jRPG_CharacterBattleStats_C_IsSameCharacterStats Parms{};

	Parms.CharacterStats_0 = CharacterStats_0;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.TryPerformBreakStun
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// E_BreakStunReason                       Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Success                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::TryPerformBreakStun(class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, E_BreakStunReason Reason, bool* Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "TryPerformBreakStun");

	Params::AC_jRPG_CharacterBattleStats_C_TryPerformBreakStun Parms{};

	Parms.SourceCharacter = SourceCharacter;
	Parms.Reason = Reason;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CanPerformBreakStun
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::CanPerformBreakStun()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CanPerformBreakStun");

	Params::AC_jRPG_CharacterBattleStats_C_CanPerformBreakStun Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.PerformBreakStun
// (Private, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// E_BreakStunReason                       Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::PerformBreakStun(class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, E_BreakStunReason Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "PerformBreakStun");

	Params::AC_jRPG_CharacterBattleStats_C_PerformBreakStun Parms{};

	Parms.SourceCharacter = SourceCharacter;
	Parms.Reason = Reason;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetIsCharacterFlying
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsFlying_0                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetIsCharacterFlying(bool IsFlying_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetIsCharacterFlying");

	Params::AC_jRPG_CharacterBattleStats_C_SetIsCharacterFlying Parms{};

	Parms.IsFlying_0 = IsFlying_0;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CanPerformAction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::CanPerformAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CanPerformAction");

	Params::AC_jRPG_CharacterBattleStats_C_CanPerformAction Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.HasForcedAutoAttack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::HasForcedAutoAttack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "HasForcedAutoAttack");

	Params::AC_jRPG_CharacterBattleStats_C_HasForcedAutoAttack Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveForcedAutoAttack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ReferenceCounterHandle&      ReferenceHandle                                        (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)

void UAC_jRPG_CharacterBattleStats_C::RemoveForcedAutoAttack(struct FSF_ReferenceCounterHandle& ReferenceHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveForcedAutoAttack");

	Params::AC_jRPG_CharacterBattleStats_C_RemoveForcedAutoAttack Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	ReferenceHandle = std::move(Parms.ReferenceHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddForcedAutoAttack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ReferenceCounterHandle&      ReferenceHandle                                        (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// const class FString&                    DebugName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddForcedAutoAttack(struct FSF_ReferenceCounterHandle& ReferenceHandle, const class FString& DebugName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddForcedAutoAttack");

	Params::AC_jRPG_CharacterBattleStats_C_AddForcedAutoAttack Parms{};

	Parms.ReferenceHandle = std::move(ReferenceHandle);
	Parms.DebugName = std::move(DebugName);

	UObject::ProcessEvent(Func, &Parms);

	ReferenceHandle = std::move(Parms.ReferenceHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsFlyingCharacter
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsFlyingCharacter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsFlyingCharacter");

	Params::AC_jRPG_CharacterBattleStats_C_IsFlyingCharacter Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsDead
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsDead()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsDead");

	Params::AC_jRPG_CharacterBattleStats_C_IsDead Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCharacterData
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UBP_CharacterData_C**             CharacterData                                          (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetCharacterData(class UBP_CharacterData_C** CharacterData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCharacterData");

	Params::AC_jRPG_CharacterBattleStats_C_GetCharacterData Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsInTeam
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// ECharacterTeamSelector                  Team                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsInTeam(ECharacterTeamSelector Team)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsInTeam");

	Params::AC_jRPG_CharacterBattleStats_C_IsInTeam Parms{};

	Parms.Team = Team;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetCurrentBreakBarDamage
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// int64                                   NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// const class FString&                    Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetCurrentBreakBarDamage(int64 NewValue, class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, const class FString& Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetCurrentBreakBarDamage");

	Params::AC_jRPG_CharacterBattleStats_C_SetCurrentBreakBarDamage Parms{};

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetStunBuffClass
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UClass*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash)

class UClass* UAC_jRPG_CharacterBattleStats_C::GetStunBuffClass()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetStunBuffClass");

	Params::AC_jRPG_CharacterBattleStats_C_GetStunBuffClass Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetBreakBarDamagePercentage
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Percentage                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// const class FString&                    Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetBreakBarDamagePercentage(double Percentage, class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, const class FString& Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetBreakBarDamagePercentage");

	Params::AC_jRPG_CharacterBattleStats_C_SetBreakBarDamagePercentage Parms{};

	Parms.Percentage = Percentage;
	Parms.SourceCharacter = SourceCharacter;
	Parms.Reason = std::move(Reason);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddBreakBarDamagePercentage
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Percentage                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// const class FString&                    Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddBreakBarDamagePercentage(double Percentage, class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, const class FString& Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddBreakBarDamagePercentage");

	Params::AC_jRPG_CharacterBattleStats_C_AddBreakBarDamagePercentage Parms{};

	Parms.Percentage = Percentage;
	Parms.SourceCharacter = SourceCharacter;
	Parms.Reason = std::move(Reason);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddBreakBarDamage
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// int64                                   DamageValue                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// const class FString&                    Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddBreakBarDamage(int64 DamageValue, class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, const class FString& Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddBreakBarDamage");

	Params::AC_jRPG_CharacterBattleStats_C_AddBreakBarDamage Parms{};

	Parms.DamageValue = DamageValue;
	Parms.SourceCharacter = SourceCharacter;
	Parms.Reason = std::move(Reason);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentBreakBarPercent
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double UAC_jRPG_CharacterBattleStats_C::GetCurrentBreakBarPercent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentBreakBarPercent");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentBreakBarPercent Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.InitBreakBar
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   BreakBarHPPercentage                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::InitBreakBar(int32 BreakBarHPPercentage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "InitBreakBar");

	Params::AC_jRPG_CharacterBattleStats_C_InitBreakBar Parms{};

	Parms.BreakBarHPPercentage = BreakBarHPPercentage;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.HasPendingResurrect
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Enabled                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::HasPendingResurrect(bool* Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "HasPendingResurrect");

	Params::AC_jRPG_CharacterBattleStats_C_HasPendingResurrect Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ResurrectInternal
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::ResurrectInternal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ResurrectInternal");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetFreeAimDamageType
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// EAttackType                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

EAttackType UAC_jRPG_CharacterBattleStats_C::GetFreeAimDamageType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetFreeAimDamageType");

	Params::AC_jRPG_CharacterBattleStats_C_GetFreeAimDamageType Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetBaseDamageType
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// EAttackType                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

EAttackType UAC_jRPG_CharacterBattleStats_C::GetBaseDamageType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetBaseDamageType");

	Params::AC_jRPG_CharacterBattleStats_C_GetBaseDamageType Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.StopInterceptingAttacksAgainstCharacter
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  CharacterStats_0                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::StopInterceptingAttacksAgainstCharacter(class UAC_jRPG_CharacterBattleStats_C* CharacterStats_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "StopInterceptingAttacksAgainstCharacter");

	Params::AC_jRPG_CharacterBattleStats_C_StopInterceptingAttacksAgainstCharacter Parms{};

	Parms.CharacterStats_0 = CharacterStats_0;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.StartInterceptingAttacksAgainstCharacter
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  CharacterStats_0                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::StartInterceptingAttacksAgainstCharacter(class UAC_jRPG_CharacterBattleStats_C* CharacterStats_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "StartInterceptingAttacksAgainstCharacter");

	Params::AC_jRPG_CharacterBattleStats_C_StartInterceptingAttacksAgainstCharacter Parms{};

	Parms.CharacterStats_0 = CharacterStats_0;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CanInterceptAttack
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  TargetedCharacter                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  AttackerCharacter                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::CanInterceptAttack(class UAC_jRPG_CharacterBattleStats_C* TargetedCharacter, class UAC_jRPG_CharacterBattleStats_C* AttackerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CanInterceptAttack");

	Params::AC_jRPG_CharacterBattleStats_C_CanInterceptAttack Parms{};

	Parms.TargetedCharacter = TargetedCharacter;
	Parms.AttackerCharacter = AttackerCharacter;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.OnBattleEnded
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::OnBattleEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "OnBattleEnded");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsDodgeLockActive
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsDodgeLockActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsDodgeLockActive");

	Params::AC_jRPG_CharacterBattleStats_C_IsDodgeLockActive Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveDodgeLock
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ReferenceCounterHandle&      LockHandle                                             (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)

void UAC_jRPG_CharacterBattleStats_C::RemoveDodgeLock(struct FSF_ReferenceCounterHandle& LockHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveDodgeLock");

	Params::AC_jRPG_CharacterBattleStats_C_RemoveDodgeLock Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	LockHandle = std::move(Parms.LockHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddDodgeLock
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FSF_ReferenceCounterHandle&      LockHandle                                             (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// const class FString&                    DebugReason                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddDodgeLock(struct FSF_ReferenceCounterHandle& LockHandle, const class FString& DebugReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddDodgeLock");

	Params::AC_jRPG_CharacterBattleStats_C_AddDodgeLock Parms{};

	Parms.LockHandle = std::move(LockHandle);
	Parms.DebugReason = std::move(DebugReason);

	UObject::ProcessEvent(Func, &Parms);

	LockHandle = std::move(Parms.LockHandle);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetTeam
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// ECharacterTeamSelector*                 Team                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetTeam(ECharacterTeamSelector* Team)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetTeam");

	Params::AC_jRPG_CharacterBattleStats_C_GetTeam Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ReceiveDamageFromObject
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Straight_Damage__ignores_calculation_                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UBP_BattleDamageBuilder_C*        DamageBuilder                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double*                                 DamageDealt                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   HasHit                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   DodgeSuccess                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   ParrySuccess                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UBP_BattleDamages_C**             BattleDamages                                          (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ReceiveDamageFromObject(double Straight_Damage__ignores_calculation_, class UBP_BattleDamageBuilder_C* DamageBuilder, double* DamageDealt, bool* HasHit, bool* DodgeSuccess, bool* ParrySuccess, class UBP_BattleDamages_C** BattleDamages)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ReceiveDamageFromObject");

	Params::AC_jRPG_CharacterBattleStats_C_ReceiveDamageFromObject Parms{};

	Parms.Straight_Damage__ignores_calculation_ = Straight_Damage__ignores_calculation_;
	Parms.DamageBuilder = DamageBuilder;

	UObject::ProcessEvent(Func, &Parms);

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

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

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

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsSkillOvercharged
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UBP_DataAsset_Skill_C*            Skill                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsSkillOvercharged(class UBP_DataAsset_Skill_C* Skill)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsSkillOvercharged");

	Params::AC_jRPG_CharacterBattleStats_C_IsSkillOvercharged Parms{};

	Parms.Skill = Skill;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetSkillScriptByTurnStartEventCriteria
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class UBP_SkillDataComponentScript_C*>*HasStartEvent                                          (Parm, OutParm)
// TArray<class UBP_SkillDataComponentScript_C*>*HasNoStartEvent                                        (Parm, OutParm)

void UAC_jRPG_CharacterBattleStats_C::GetSkillScriptByTurnStartEventCriteria(TArray<class UBP_SkillDataComponentScript_C*>* HasStartEvent, TArray<class UBP_SkillDataComponentScript_C*>* HasNoStartEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetSkillScriptByTurnStartEventCriteria");

	Params::AC_jRPG_CharacterBattleStats_C_GetSkillScriptByTurnStartEventCriteria Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentAPPercentage01
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Percent01                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetCurrentAPPercentage01(double* Percent01)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentAPPercentage01");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentAPPercentage01 Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetRuntimeStatValue
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// ERuntimeBattleStatType                  StatType                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetRuntimeStatValue(ERuntimeBattleStatType StatType, double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetRuntimeStatValue");

	Params::AC_jRPG_CharacterBattleStats_C_GetRuntimeStatValue Parms{};

	Parms.StatType = StatType;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.Force Play Again
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ShouldPlayTooltip                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    PreventChainedPlayAgain                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   HasAppliedForcePlayAgain                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::Force_Play_Again(bool ShouldPlayTooltip, bool PreventChainedPlayAgain, bool* HasAppliedForcePlayAgain)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "Force Play Again");

	Params::AC_jRPG_CharacterBattleStats_C_Force_Play_Again Parms{};

	Parms.ShouldPlayTooltip = ShouldPlayTooltip;
	Parms.PreventChainedPlayAgain = PreventChainedPlayAgain;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.TryDisableGradientPostProcess
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    DuringCounter                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   GradientCenterLocation                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::TryDisableGradientPostProcess(bool DuringCounter, const struct FVector& GradientCenterLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "TryDisableGradientPostProcess");

	Params::AC_jRPG_CharacterBattleStats_C_TryDisableGradientPostProcess Parms{};

	Parms.DuringCounter = DuringCounter;
	Parms.GradientCenterLocation = std::move(GradientCenterLocation);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RegisterSkillChecks
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBP_DataAsset_Skill_C*            Skill                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::RegisterSkillChecks(class UBP_DataAsset_Skill_C* Skill)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RegisterSkillChecks");

	Params::AC_jRPG_CharacterBattleStats_C_RegisterSkillChecks Parms{};

	Parms.Skill = Skill;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.DrainAP
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacterStats                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::DrainAP(int32 Amount, class UAC_jRPG_CharacterBattleStats_C* SourceCharacterStats)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "DrainAP");

	Params::AC_jRPG_CharacterBattleStats_C_DrainAP Parms{};

	Parms.Amount = Amount;
	Parms.SourceCharacterStats = SourceCharacterStats;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.Drain_AP_FromTarget
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  TargetCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// int32                                   Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::Drain_AP_FromTarget(class UAC_jRPG_CharacterBattleStats_C* TargetCharacter, int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "Drain_AP_FromTarget");

	Params::AC_jRPG_CharacterBattleStats_C_Drain_AP_FromTarget Parms{};

	Parms.TargetCharacter = TargetCharacter;
	Parms.Amount = Amount;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CheckForDeath
// (Private, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBP_BattleDamages_C*              BattleDamages                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::CheckForDeath(class UBP_BattleDamages_C* BattleDamages)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CheckForDeath");

	Params::AC_jRPG_CharacterBattleStats_C_CheckForDeath Parms{};

	Parms.BattleDamages = BattleDamages;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetDead
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::SetDead()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetDead");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetCharacterFleeing
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    IsFleeing_0                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetCharacterFleeing(bool IsFleeing_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetCharacterFleeing");

	Params::AC_jRPG_CharacterBattleStats_C_SetCharacterFleeing Parms{};

	Parms.IsFleeing_0 = IsFleeing_0;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentShieldPoints
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// int32*                                  ShieldPoints                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetCurrentShieldPoints(int32* ShieldPoints)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentShieldPoints");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentShieldPoints Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetCurrentShieldPoints
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   NewValue                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FString&                    DebugReason                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetCurrentShieldPoints(int32 NewValue, const class FString& DebugReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetCurrentShieldPoints");

	Params::AC_jRPG_CharacterBattleStats_C_SetCurrentShieldPoints Parms{};

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddShieldPoints
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FString&                    DebugReason                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddShieldPoints(int32 Amount, const class FString& DebugReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddShieldPoints");

	Params::AC_jRPG_CharacterBattleStats_C_AddShieldPoints Parms{};

	Parms.Amount = Amount;
	Parms.DebugReason = std::move(DebugReason);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.TryConsumeShieldPoints
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FString&                    DebugReason                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// bool*                                   Success                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::TryConsumeShieldPoints(int32 Amount, const class FString& DebugReason, bool* Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "TryConsumeShieldPoints");

	Params::AC_jRPG_CharacterBattleStats_C_TryConsumeShieldPoints Parms{};

	Parms.Amount = Amount;
	Parms.DebugReason = std::move(DebugReason);

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.NotifyDeath
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    DeathCounter                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::NotifyDeath(bool DeathCounter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "NotifyDeath");

	Params::AC_jRPG_CharacterBattleStats_C_NotifyDeath Parms{};

	Parms.DeathCounter = DeathCounter;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.FindEquippedSkillByID
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class FName                             SkillID                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UBP_DataAsset_Skill_C**           Skill                                                  (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::FindEquippedSkillByID(class FName SkillID, class UBP_DataAsset_Skill_C** Skill)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "FindEquippedSkillByID");

	Params::AC_jRPG_CharacterBattleStats_C_FindEquippedSkillByID Parms{};

	Parms.SkillID = SkillID;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.TriggerSkill
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class ABP_jRPG_Character_Battle_Base_C*>&TargetedCharacters_0                                   (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// class UClass*                           SkillClass                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::TriggerSkill(TArray<class ABP_jRPG_Character_Battle_Base_C*>& TargetedCharacters_0, class UClass* SkillClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "TriggerSkill");

	Params::AC_jRPG_CharacterBattleStats_C_TriggerSkill Parms{};

	Parms.TargetedCharacters_0 = std::move(TargetedCharacters_0);
	Parms.SkillClass = SkillClass;

	UObject::ProcessEvent(Func, &Parms);

	TargetedCharacters_0 = std::move(Parms.TargetedCharacters_0);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.UpdateSkillStates
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::UpdateSkillStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "UpdateSkillStates");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetAllSkillStatesForUI
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TMap<class UBP_DataAsset_Skill_C*, class UBP_SkillState_C*>*SkillStates_0                                          (Parm, OutParm)

void UAC_jRPG_CharacterBattleStats_C::GetAllSkillStatesForUI(TMap<class UBP_DataAsset_Skill_C*, class UBP_SkillState_C*>* SkillStates_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetAllSkillStatesForUI");

	Params::AC_jRPG_CharacterBattleStats_C_GetAllSkillStatesForUI Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetSkillState
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const class UBP_DataAsset_Skill_C*      SkillData                                              (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UBP_SkillState_C**                Value                                                  (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetSkillState(const class UBP_DataAsset_Skill_C* SkillData, class UBP_SkillState_C** Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetSkillState");

	Params::AC_jRPG_CharacterBattleStats_C_GetSkillState Parms{};

	Parms.SkillData = SkillData;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetProbabilityToReceiveBuff
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// EBuffApplicationProbability             StatusEffectProbability                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UBP_BattleBuffInstance_C*         BuffInstance                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double UAC_jRPG_CharacterBattleStats_C::GetProbabilityToReceiveBuff(class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, EBuffApplicationProbability StatusEffectProbability, class UBP_BattleBuffInstance_C* BuffInstance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetProbabilityToReceiveBuff");

	Params::AC_jRPG_CharacterBattleStats_C_GetProbabilityToReceiveBuff Parms{};

	Parms.SourceCharacter = SourceCharacter;
	Parms.StatusEffectProbability = StatusEffectProbability;
	Parms.BuffInstance = BuffInstance;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.DeinitBattleGear
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::DeinitBattleGear()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "DeinitBattleGear");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetDefenseAgainstElement
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// EAttackType                             AttackElement                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Defense                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetDefenseAgainstElement(EAttackType AttackElement, double* Defense)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetDefenseAgainstElement");

	Params::AC_jRPG_CharacterBattleStats_C_GetDefenseAgainstElement Parms{};

	Parms.AttackElement = AttackElement;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.PrepareForActionAsSkillCaster
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::PrepareForActionAsSkillCaster()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "PrepareForActionAsSkillCaster");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.PrepareForActionAsSkillTarget
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::PrepareForActionAsSkillTarget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "PrepareForActionAsSkillTarget");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.InitSkillStates
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::InitSkillStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "InitSkillStates");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.DEBUG_Console_AutoGradientParry
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::DEBUG_Console_AutoGradientParry()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "DEBUG_Console_AutoGradientParry");

	Params::AC_jRPG_CharacterBattleStats_C_DEBUG_Console_AutoGradientParry Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetAttackPowerForType
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// EAttackType                             AttackElement                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Power                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetAttackPowerForType(EAttackType AttackElement, double* Power)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetAttackPowerForType");

	Params::AC_jRPG_CharacterBattleStats_C_GetAttackPowerForType Parms{};

	Parms.AttackElement = AttackElement;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsDefenseLockActive
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsDefenseLockActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsDefenseLockActive");

	Params::AC_jRPG_CharacterBattleStats_C_IsDefenseLockActive Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveDefenseLock
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::RemoveDefenseLock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveDefenseLock");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddDefenseLock
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::AddDefenseLock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddDefenseLock");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.IsTurnSkipActive
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::IsTurnSkipActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "IsTurnSkipActive");

	Params::AC_jRPG_CharacterBattleStats_C_IsTurnSkipActive Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveTurnSkip
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::RemoveTurnSkip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveTurnSkip");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddTurnSkip
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::AddTurnSkip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddTurnSkip");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetPassiveFromBuff
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const class UBP_BattleBuffInstance_C*&  Key                                                    (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash)
// struct FFPassiveEffect*                 PassiveEffect                                          (Parm, OutParm, HasGetValueTypeHash)
// class FName*                            PassiveID                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Found                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetPassiveFromBuff(const class UBP_BattleBuffInstance_C*& Key, struct FFPassiveEffect* PassiveEffect, class FName* PassiveID, bool* Found)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetPassiveFromBuff");

	Params::AC_jRPG_CharacterBattleStats_C_GetPassiveFromBuff Parms{};

	Parms.Key = Key;

	UObject::ProcessEvent(Func, &Parms);

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

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentSpeedSimulate
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    HasEngagementBonus_0                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double UAC_jRPG_CharacterBattleStats_C::GetCurrentSpeedSimulate(bool HasEngagementBonus_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentSpeedSimulate");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentSpeedSimulate Parms{};

	Parms.HasEngagementBonus_0 = HasEngagementBonus_0;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentSpeed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

double UAC_jRPG_CharacterBattleStats_C::GetCurrentSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentSpeed");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentSpeed Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentHPPercentage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Percent01                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetCurrentHPPercentage(double* Percent01)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentHPPercentage");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentHPPercentage Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.OnKilledByDamage
// (Private, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBP_BattleDamages_C*              BattleDamages                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::OnKilledByDamage(class UBP_BattleDamages_C* BattleDamages)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "OnKilledByDamage");

	Params::AC_jRPG_CharacterBattleStats_C_OnKilledByDamage Parms{};

	Parms.BattleDamages = BattleDamages;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CanSpendAP
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// int32                                   Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::CanSpendAP(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CanSpendAP");

	Params::AC_jRPG_CharacterBattleStats_C_CanSpendAP Parms{};

	Parms.Amount = Amount;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetAP
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   NewAP                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EAPChangeReason                         ChangeReason                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetAP(int32 NewAP, EAPChangeReason ChangeReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetAP");

	Params::AC_jRPG_CharacterBattleStats_C_SetAP Parms{};

	Parms.NewAP = NewAP;
	Parms.ChangeReason = ChangeReason;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CheckIsAlive2
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    CheckMode                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UBP_BattleCheckContext_C*         NewParam                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::CheckIsAlive2(bool CheckMode, class UBP_BattleCheckContext_C* NewParam, bool* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CheckIsAlive2");

	Params::AC_jRPG_CharacterBattleStats_C_CheckIsAlive2 Parms{};

	Parms.CheckMode = CheckMode;
	Parms.NewParam = NewParam;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CheckCanResurrect
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    CheckMode                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::CheckCanResurrect(bool CheckMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CheckCanResurrect");

	Params::AC_jRPG_CharacterBattleStats_C_CheckCanResurrect Parms{};

	Parms.CheckMode = CheckMode;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CheckCanRecoverHP
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    CheckMode                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   CanRecover                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   BecauseDead                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   BecauseMaxHP                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::CheckCanRecoverHP(bool CheckMode, bool* CanRecover, bool* BecauseDead, bool* BecauseMaxHP)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CheckCanRecoverHP");

	Params::AC_jRPG_CharacterBattleStats_C_CheckCanRecoverHP Parms{};

	Parms.CheckMode = CheckMode;

	UObject::ProcessEvent(Func, &Parms);

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

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CheckIsMaxed
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    CheckMode                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::CheckIsMaxed(bool CheckMode, bool* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CheckIsMaxed");

	Params::AC_jRPG_CharacterBattleStats_C_CheckIsMaxed Parms{};

	Parms.CheckMode = CheckMode;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CheckIsAlive
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    CheckMode                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::CheckIsAlive(bool CheckMode, bool* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CheckIsAlive");

	Params::AC_jRPG_CharacterBattleStats_C_CheckIsAlive Parms{};

	Parms.CheckMode = CheckMode;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.InvalidateCheck
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             CheckName                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::InvalidateCheck(class FName CheckName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "InvalidateCheck");

	Params::AC_jRPG_CharacterBattleStats_C_InvalidateCheck Parms{};

	Parms.CheckName = CheckName;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddCheckStack
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             CheckConstant                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    CheckMode                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddCheckStack(class FName CheckConstant, bool CheckMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddCheckStack");

	Params::AC_jRPG_CharacterBattleStats_C_AddCheckStack Parms{};

	Parms.CheckConstant = CheckConstant;
	Parms.CheckMode = CheckMode;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ResetChecks
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::ResetChecks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ResetChecks");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.Assert Check
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             CheckConstant                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FString&                    OperationName                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::Assert_Check(class FName CheckConstant, const class FString& OperationName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "Assert Check");

	Params::AC_jRPG_CharacterBattleStats_C_Assert_Check Parms{};

	Parms.CheckConstant = CheckConstant;
	Parms.OperationName = std::move(OperationName);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CanRecoverHP
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool*                                   Valid                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   BecauseDead                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::CanRecoverHP(bool* Valid, bool* BecauseDead)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CanRecoverHP");

	Params::AC_jRPG_CharacterBattleStats_C_CanRecoverHP Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.OnParryPerfectFail
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FText&                      Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm)

void UAC_jRPG_CharacterBattleStats_C::OnParryPerfectFail(const class FText& Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "OnParryPerfectFail");

	Params::AC_jRPG_CharacterBattleStats_C_OnParryPerfectFail Parms{};

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.DEBUG_Console_AutoDodge
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::DEBUG_Console_AutoDodge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "DEBUG_Console_AutoDodge");

	Params::AC_jRPG_CharacterBattleStats_C_DEBUG_Console_AutoDodge Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.DEBUG_Console_AutoParry
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UAC_jRPG_CharacterBattleStats_C::DEBUG_Console_AutoParry()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "DEBUG_Console_AutoParry");

	Params::AC_jRPG_CharacterBattleStats_C_DEBUG_Console_AutoParry Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ComputeNewInitiativeAfterTimeSimulate
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  CurrentInitiative_0                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Time                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    HasEngagementBonus_0                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    DEBUG_Verbose                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 NewInitiative                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ComputeNewInitiativeAfterTimeSimulate(double CurrentInitiative_0, double Time, bool HasEngagementBonus_0, bool DEBUG_Verbose, double* NewInitiative)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ComputeNewInitiativeAfterTimeSimulate");

	Params::AC_jRPG_CharacterBattleStats_C_ComputeNewInitiativeAfterTimeSimulate Parms{};

	Parms.CurrentInitiative_0 = CurrentInitiative_0;
	Parms.Time = Time;
	Parms.HasEngagementBonus_0 = HasEngagementBonus_0;
	Parms.DEBUG_Verbose = DEBUG_Verbose;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AdvanceInitiativeByTime
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Time                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    DEBUG_Verbose                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AdvanceInitiativeByTime(double Time, bool DEBUG_Verbose)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AdvanceInitiativeByTime");

	Params::AC_jRPG_CharacterBattleStats_C_AdvanceInitiativeByTime Parms{};

	Parms.Time = Time;
	Parms.DEBUG_Verbose = DEBUG_Verbose;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetTimeToFullInitiativeSimulate
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double                                  CurrentInitiative_0                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    HasEngagementBonus_0                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 Time                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetTimeToFullInitiativeSimulate(double CurrentInitiative_0, bool HasEngagementBonus_0, double* Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetTimeToFullInitiativeSimulate");

	Params::AC_jRPG_CharacterBattleStats_C_GetTimeToFullInitiativeSimulate Parms{};

	Parms.CurrentInitiative_0 = CurrentInitiative_0;
	Parms.HasEngagementBonus_0 = HasEngagementBonus_0;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetTimeToFullInitiative
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 Time                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetTimeToFullInitiative(double* Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetTimeToFullInitiative");

	Params::AC_jRPG_CharacterBattleStats_C_GetTimeToFullInitiative Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetMaxAP
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 MaxMP                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetMaxAP(double* MaxMP)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetMaxAP");

	Params::AC_jRPG_CharacterBattleStats_C_GetMaxAP Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetMaxHP
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 MaxHP                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetMaxHP(double* MaxHP)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetMaxHP");

	Params::AC_jRPG_CharacterBattleStats_C_GetMaxHP Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.InitBattleGear
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::InitBattleGear()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "InitBattleGear");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetOtherElementalAffinity
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  CharacterBattleStats                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// EAttackType                             AttackType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EElementalAffinity*                     Affinity                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetOtherElementalAffinity(class UAC_jRPG_CharacterBattleStats_C* CharacterBattleStats, EAttackType AttackType, EElementalAffinity* Affinity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetOtherElementalAffinity");

	Params::AC_jRPG_CharacterBattleStats_C_GetOtherElementalAffinity Parms{};

	Parms.CharacterBattleStats = CharacterBattleStats;
	Parms.AttackType = AttackType;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetElementalAffinity
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// EAttackType                             AttackType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EElementalAffinity*                     Affinity                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetElementalAffinity(EAttackType AttackType, EElementalAffinity* Affinity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetElementalAffinity");

	Params::AC_jRPG_CharacterBattleStats_C_GetElementalAffinity Parms{};

	Parms.AttackType = AttackType;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.MaxHP
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::MaxHP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "MaxHP");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetHP
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  HP_Value                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetHP(double HP_Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetHP");

	Params::AC_jRPG_CharacterBattleStats_C_SetHP Parms{};

	Parms.HP_Value = HP_Value;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.OnOverrideFull
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::OnOverrideFull()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "OnOverrideFull");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddOverdrive
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FText&                      Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm)

void UAC_jRPG_CharacterBattleStats_C::AddOverdrive(double Amount, const class FText& Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddOverdrive");

	Params::AC_jRPG_CharacterBattleStats_C_AddOverdrive Parms{};

	Parms.Amount = Amount;
	Parms.Reason = std::move(Reason);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.OnBuffDeactivated
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBP_BattleBuffInstanceWrapper_C*  BuffInstanceWrapper                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::OnBuffDeactivated(class UBP_BattleBuffInstanceWrapper_C* BuffInstanceWrapper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "OnBuffDeactivated");

	Params::AC_jRPG_CharacterBattleStats_C_OnBuffDeactivated Parms{};

	Parms.BuffInstanceWrapper = BuffInstanceWrapper;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.OnCharacterTurnStart
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAC_jRPG_CharacterBattleStats_C*  CharacterTurn                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::OnCharacterTurnStart(class UAC_jRPG_CharacterBattleStats_C* CharacterTurn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "OnCharacterTurnStart");

	Params::AC_jRPG_CharacterBattleStats_C_OnCharacterTurnStart Parms{};

	Parms.CharacterTurn = CharacterTurn;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RecalculateStats
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::RecalculateStats()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RecalculateStats");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveStatMultiplier
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FGuid&                     StatMultiplierUID                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::RemoveStatMultiplier(const struct FGuid& StatMultiplierUID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveStatMultiplier");

	Params::AC_jRPG_CharacterBattleStats_C_RemoveStatMultiplier Parms{};

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddStatMultiplier
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// E_jRPG_StatType                         StatType                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Multiplier                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FGuid*                           StatMultiplierUID                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddStatMultiplier(E_jRPG_StatType StatType, double Multiplier, struct FGuid* StatMultiplierUID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddStatMultiplier");

	Params::AC_jRPG_CharacterBattleStats_C_AddStatMultiplier Parms{};

	Parms.StatType = StatType;
	Parms.Multiplier = Multiplier;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ActivateBuff
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBP_BattleBuffInstance_C*         BuffInstance                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// EBuffApplicationProbability             StatusEffectProbability                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool*                                   Success                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ActivateBuff(class UBP_BattleBuffInstance_C* BuffInstance, EBuffApplicationProbability StatusEffectProbability, class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, bool* Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ActivateBuff");

	Params::AC_jRPG_CharacterBattleStats_C_ActivateBuff Parms{};

	Parms.BuffInstance = BuffInstance;
	Parms.StatusEffectProbability = StatusEffectProbability;
	Parms.SourceCharacter = SourceCharacter;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.Resurrect
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  HP_Amount                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::Resurrect(double HP_Amount, class UAC_jRPG_CharacterBattleStats_C* SourceCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "Resurrect");

	Params::AC_jRPG_CharacterBattleStats_C_Resurrect Parms{};

	Parms.HP_Amount = HP_Amount;
	Parms.SourceCharacter = SourceCharacter;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ReduceAP
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EAPChangeReason                         ChangeReason                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ReduceAP(double Amount, EAPChangeReason ChangeReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ReduceAP");

	Params::AC_jRPG_CharacterBattleStats_C_ReduceAP Parms{};

	Parms.Amount = Amount;
	Parms.ChangeReason = ChangeReason;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GainAP
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EAPChangeReason                         ChangeReason                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GainAP(int32 Amount, EAPChangeReason ChangeReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GainAP");

	Params::AC_jRPG_CharacterBattleStats_C_GainAP Parms{};

	Parms.Amount = Amount;
	Parms.ChangeReason = ChangeReason;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCurrentAP
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// double*                                 AP                                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetCurrentAP(double* AP)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCurrentAP");

	Params::AC_jRPG_CharacterBattleStats_C_GetCurrentAP Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ReduceHP
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 NewHPValue                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 EffectiveDamage                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ReduceHP(double Amount, double* NewHPValue, double* EffectiveDamage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ReduceHP");

	Params::AC_jRPG_CharacterBattleStats_C_ReduceHP Parms{};

	Parms.Amount = Amount;

	UObject::ProcessEvent(Func, &Parms);

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ReduceInitiative
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ReduceInitiative(double Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ReduceInitiative");

	Params::AC_jRPG_CharacterBattleStats_C_ReduceInitiative Parms{};

	Parms.Amount = Amount;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CalculateDefendStanceDamageReduction
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  DamageInput                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double*                                 DamageOutput                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::CalculateDefendStanceDamageReduction(double DamageInput, double* DamageOutput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CalculateDefendStanceDamageReduction");

	Params::AC_jRPG_CharacterBattleStats_C_CalculateDefendStanceDamageReduction Parms{};

	Parms.DamageInput = DamageInput;

	UObject::ProcessEvent(Func, &Parms);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RemoveInitiative
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::RemoveInitiative(double Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RemoveInitiative");

	Params::AC_jRPG_CharacterBattleStats_C_RemoveInitiative Parms{};

	Parms.Amount = Amount;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ReceiveDamage
// (Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  FinalDamageMultiplier                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// TScriptInterface<class IIBattleDamageSource_C>DamageSourceCharacter                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EAttackType                             AttackType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Simulated_Damage__No_Damage_will_be_dealt_             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Straight_Damage__ignores_calculation_                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsCounterDamage                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EDamageReason                           DamageReason                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   DamageLocation                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FString&                    DebugReason                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// double*                                 DamageDealt                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   HasHit                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   DodgeSuccess                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   ParrySuccess                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool*                                   QTESuccess_                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UBP_BattleDamages_C**             BattleDamages                                          (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ReceiveDamage(double FinalDamageMultiplier, TScriptInterface<class IIBattleDamageSource_C> DamageSourceCharacter, EAttackType AttackType, bool Simulated_Damage__No_Damage_will_be_dealt_, double Straight_Damage__ignores_calculation_, bool IsCounterDamage, EDamageReason DamageReason, const struct FVector& DamageLocation, const class FString& DebugReason, double* DamageDealt, bool* HasHit, bool* DodgeSuccess, bool* ParrySuccess, bool* QTESuccess_, class UBP_BattleDamages_C** BattleDamages)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ReceiveDamage");

	Params::AC_jRPG_CharacterBattleStats_C_ReceiveDamage Parms{};

	Parms.FinalDamageMultiplier = FinalDamageMultiplier;
	Parms.DamageSourceCharacter = DamageSourceCharacter;
	Parms.AttackType = AttackType;
	Parms.Simulated_Damage__No_Damage_will_be_dealt_ = Simulated_Damage__No_Damage_will_be_dealt_;
	Parms.Straight_Damage__ignores_calculation_ = Straight_Damage__ignores_calculation_;
	Parms.IsCounterDamage = IsCounterDamage;
	Parms.DamageReason = DamageReason;
	Parms.DamageLocation = std::move(DamageLocation);
	Parms.DebugReason = std::move(DebugReason);

	UObject::ProcessEvent(Func, &Parms);

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

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

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

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

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

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.RecoverHP
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  RecoveryAmount                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UAC_jRPG_CharacterBattleStats_C*  SourceCharacter                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool                                    PlayVFX                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// EHealReason                             Reason                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FString&                    DebugReason                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::RecoverHP(double RecoveryAmount, class UAC_jRPG_CharacterBattleStats_C* SourceCharacter, bool PlayVFX, EHealReason Reason, const class FString& DebugReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "RecoverHP");

	Params::AC_jRPG_CharacterBattleStats_C_RecoverHP Parms{};

	Parms.RecoveryAmount = RecoveryAmount;
	Parms.SourceCharacter = SourceCharacter;
	Parms.PlayVFX = PlayVFX;
	Parms.Reason = Reason;
	Parms.DebugReason = std::move(DebugReason);

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.AddInitiative
// (Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  Amount                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::AddInitiative(double Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "AddInitiative");

	Params::AC_jRPG_CharacterBattleStats_C_AddInitiative Parms{};

	Parms.Amount = Amount;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.CreateCharacterBattleSlotUI
// (Public, BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::CreateCharacterBattleSlotUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "CreateCharacterBattleSlotUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetCharacterDataFromHero
// (Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBP_CharacterData_C*              HeroCharacterData                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::SetCharacterDataFromHero(class UBP_CharacterData_C* HeroCharacterData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetCharacterDataFromHero");

	Params::AC_jRPG_CharacterBattleStats_C_SetCharacterDataFromHero Parms{};

	Parms.HeroCharacterData = HeroCharacterData;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.SetCharacterData
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             HardcodedID                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const class FText&                      CharacterDisplayName_0                                 (BlueprintVisible, BlueprintReadOnly, Parm)
// ETextGender                             GenderTag_0                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const TMap<E_jRPG_StatType, double>&    CharacterStats_0                                       (BlueprintVisible, BlueprintReadOnly, Parm)
// double                                  CurrentHealth                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  CurrentMana                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FS_jRPG_OverdriveSource&   OverdriveSources_0                                     (BlueprintVisible, BlueprintReadOnly, Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UTexture2D*                       CharacterBattleIcon_0                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FFCharacterStats&                CommonCharacterStats                                   (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsBoss_0                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    IsFlying_0                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const TMap<EAttackType, EElementalAffinity>&ElementalAffinities                                    (BlueprintVisible, BlueprintReadOnly, Parm)

void UAC_jRPG_CharacterBattleStats_C::SetCharacterData(class FName HardcodedID, const class FText& CharacterDisplayName_0, ETextGender GenderTag_0, const TMap<E_jRPG_StatType, double>& CharacterStats_0, double CurrentHealth, double CurrentMana, const struct FS_jRPG_OverdriveSource& OverdriveSources_0, class UTexture2D* CharacterBattleIcon_0, struct FFCharacterStats& CommonCharacterStats, bool IsBoss_0, bool IsFlying_0, const TMap<EAttackType, EElementalAffinity>& ElementalAffinities)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "SetCharacterData");

	Params::AC_jRPG_CharacterBattleStats_C_SetCharacterData Parms{};

	Parms.HardcodedID = HardcodedID;
	Parms.CharacterDisplayName_0 = std::move(CharacterDisplayName_0);
	Parms.GenderTag_0 = GenderTag_0;
	Parms.CharacterStats_0 = std::move(CharacterStats_0);
	Parms.CurrentHealth = CurrentHealth;
	Parms.CurrentMana = CurrentMana;
	Parms.OverdriveSources_0 = std::move(OverdriveSources_0);
	Parms.CharacterBattleIcon_0 = CharacterBattleIcon_0;
	Parms.CommonCharacterStats = std::move(CommonCharacterStats);
	Parms.IsBoss_0 = IsBoss_0;
	Parms.IsFlying_0 = IsFlying_0;
	Parms.ElementalAffinities = std::move(ElementalAffinities);

	UObject::ProcessEvent(Func, &Parms);

	CommonCharacterStats = std::move(Parms.CommonCharacterStats);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ReceiveBeginPlay
// (Event, Public, BlueprintEvent)

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

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

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.Internal_BeginPrepareForBattle
// (BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::Internal_BeginPrepareForBattle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "Internal_BeginPrepareForBattle");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ProcessSkillComponentStartEvents
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// const class USF_BlueprintLatentAction*  LatentAction                                           (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    ForceInstant                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ProcessSkillComponentStartEvents(const class USF_BlueprintLatentAction* LatentAction, bool ForceInstant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ProcessSkillComponentStartEvents");

	Params::AC_jRPG_CharacterBattleStats_C_ProcessSkillComponentStartEvents Parms{};

	Parms.LatentAction = LatentAction;
	Parms.ForceInstant = ForceInstant;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.BattleStart_SkillComponents_ProcessNext
// (BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::BattleStart_SkillComponents_ProcessNext()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "BattleStart_SkillComponents_ProcessNext");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.BattleStart_SkillComponent_OnAllProcessed
// (BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::BattleStart_SkillComponent_OnAllProcessed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "BattleStart_SkillComponent_OnAllProcessed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.Internal_FinishPrepareForBattle
// (BlueprintCallable, BlueprintEvent)

void UAC_jRPG_CharacterBattleStats_C::Internal_FinishPrepareForBattle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "Internal_FinishPrepareForBattle");

	UObject::ProcessEvent(Func, nullptr);
}


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ReceiveEndPlay
// (Event, Public, BlueprintEvent)
// Parameters:
// EEndPlayReason                          EndPlayReason                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ReceiveEndPlay(EEndPlayReason EndPlayReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ReceiveEndPlay");

	Params::AC_jRPG_CharacterBattleStats_C_ReceiveEndPlay Parms{};

	Parms.EndPlayReason = EndPlayReason;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.ExecuteUbergraph_AC_jRPG_CharacterBattleStats
// (Final, UbergraphFunction, HasDefaults)
// Parameters:
// int32                                   EntryPoint                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::ExecuteUbergraph_AC_jRPG_CharacterBattleStats(int32 EntryPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "ExecuteUbergraph_AC_jRPG_CharacterBattleStats");

	Params::AC_jRPG_CharacterBattleStats_C_ExecuteUbergraph_AC_jRPG_CharacterBattleStats Parms{};

	Parms.EntryPoint = EntryPoint;

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


// Function AC_jRPG_CharacterBattleStats.AC_jRPG_CharacterBattleStats_C.GetCharacterBattleBase
// (Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class ABP_jRPG_Character_Battle_Base_C**jRPG_CharacterBattleBase                               (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   IsValid                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UAC_jRPG_CharacterBattleStats_C::GetCharacterBattleBase(class ABP_jRPG_Character_Battle_Base_C** jRPG_CharacterBattleBase, bool* IsValid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AC_jRPG_CharacterBattleStats_C", "GetCharacterBattleBase");

	Params::AC_jRPG_CharacterBattleStats_C_GetCharacterBattleBase Parms{};

	UObject::ProcessEvent(Func, &Parms);

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

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

}