#pragma once

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

// Package: Phoenix

#include "Basic.hpp"

#include "Phoenix_classes.hpp"
#include "Phoenix_parameters.hpp"


namespace SDK
{

// Function Phoenix.State.AddAllChildStates
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FStateRef&                 DefaultState                                           (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UState::AddAllChildStates(const struct FStateRef& DefaultState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "AddAllChildStates");

	Params::State_AddAllChildStates Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.AddChildState
// (Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UState>               StateClass                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   EnumId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UState*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UState* UState::AddChildState(TSubclassOf<class UState> StateClass, class FName ID, uint8 EnumId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "AddChildState");

	Params::State_AddChildState Parms{};

	Parms.StateClass = StateClass;
	Parms.ID = ID;
	Parms.EnumId = EnumId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.AddChildStateRef
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FStateRef&                 StateRef                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// uint8                                   EnumId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UState*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UState* UState::AddChildStateRef(const struct FStateRef& StateRef, uint8 EnumId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "AddChildStateRef");

	Params::State_AddChildStateRef Parms{};

	Parms.StateRef = std::move(StateRef);
	Parms.EnumId = EnumId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.AddSiblingState
// (Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UState>               StateClass                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UState*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UState* UState::AddSiblingState(TSubclassOf<class UState> StateClass, class FName ID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "AddSiblingState");

	Params::State_AddSiblingState Parms{};

	Parms.StateClass = StateClass;
	Parms.ID = ID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.AddSiblingStateRef
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FStateRef&                 StateRef                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)
// class UState*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UState* UState::AddSiblingStateRef(const struct FStateRef& StateRef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "AddSiblingStateRef");

	Params::State_AddSiblingStateRef Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.Begin
// (Native, Public)
// Parameters:
// const class UStateParams*               Params_0                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::Begin(const class UStateParams* Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "Begin");

	Params::State_Begin Parms{};

	Parms.Params_0 = Params_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.BeginChild
// (Native, Protected)
// Parameters:
// const class UStateParams*               Params_0                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::BeginChild(const class UStateParams* Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "BeginChild");

	Params::State_BeginChild Parms{};

	Parms.Params_0 = Params_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.ClearFrameSpanInputs
// (Native, Public)

void UState::ClearFrameSpanInputs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "ClearFrameSpanInputs");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.ClearStateSpanInputs
// (Native, Public)

void UState::ClearStateSpanInputs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "ClearStateSpanInputs");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.End
// (Native, Public)

void UState::End()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "End");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.GetDebugDisplayText
// (Native, Public)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UState::GetDebugDisplayText()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "GetDebugDisplayText");

	Params::State_GetDebugDisplayText Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.Init
// (Native, Public)
// Parameters:
// class UObject*                          OwnerParam                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UState*                           ParentState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::Init(class UObject* OwnerParam, class UState* ParentState, class FName ID)
{
	static class UFunction* Func = nullptr;

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

	Params::State_Init Parms{};

	Parms.OwnerParam = OwnerParam;
	Parms.ParentState = ParentState;
	Parms.ID = ID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.InitAllChildStateNames
// (Native, Public, BlueprintCallable)

void UState::InitAllChildStateNames()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "InitAllChildStateNames");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.IsSelfFinished
// (Final, Native, Public)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UState::IsSelfFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "IsSelfFinished");

	Params::State_IsSelfFinished Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.IsStateFinished
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UState::IsStateFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "IsStateFinished");

	Params::State_IsStateFinished Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.State.OnBegin
// (Event, Public, BlueprintEvent)
// Parameters:
// const class UStateParams*               Params_0                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::OnBegin(const class UStateParams* Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "OnBegin");

	Params::State_OnBegin Parms{};

	Parms.Params_0 = Params_0;

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


// Function Phoenix.State.OnEnd
// (Event, Public, BlueprintEvent)

void UState::OnEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "OnEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.State.OnInit
// (Event, Public, BlueprintEvent)

void UState::OnInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "OnInit");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.State.OnStateChange
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             OldStateID                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NewStateID                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::OnStateChange(class FName OldStateID, class FName NewStateID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "OnStateChange");

	Params::State_OnStateChange Parms{};

	Parms.OldStateID = OldStateID;
	Parms.NewStateID = NewStateID;

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


// Function Phoenix.State.OnTick
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::OnTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "OnTick");

	Params::State_OnTick Parms{};

	Parms.DeltaTime = DeltaTime;

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


// Function Phoenix.State.RefreshInputs
// (Native, Public)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::RefreshInputs(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "RefreshInputs");

	Params::State_RefreshInputs Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.RemoveChildState
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FStateRef&                 StateRef                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UState::RemoveChildState(const struct FStateRef& StateRef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "RemoveChildState");

	Params::State_RemoveChildState Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.ShouldWaitForChildToFinish
// (Final, Native, Public)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UState::ShouldWaitForChildToFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "ShouldWaitForChildToFinish");

	Params::State_ShouldWaitForChildToFinish Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.Tick
// (Native, Public)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UState::Tick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "Tick");

	Params::State_Tick Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.State.GetActiveChild
// (Final, Native, Public, Const)
// Parameters:
// class UState*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UState* UState::GetActiveChild() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "GetActiveChild");

	Params::State_GetActiveChild Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.GetDeepestTimeActive
// (Final, Native, Public, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UState::GetDeepestTimeActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "GetDeepestTimeActive");

	Params::State_GetDeepestTimeActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.GetStateID
// (Final, Native, Public, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UState::GetStateID() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "GetStateID");

	Params::State_GetStateID Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.GetTimeActive
// (Final, Native, Public, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UState::GetTimeActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "GetTimeActive");

	Params::State_GetTimeActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.IsActive
// (Final, Native, Public, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UState::IsActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "IsActive");

	Params::State_IsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.State.IsSelfFinisher
// (Final, Native, Public, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UState::IsSelfFinisher() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("State", "IsSelfFinisher");

	Params::State_IsSelfFinisher Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAnimNotify.GetSourceObject
// (Final, Native, Public, Const)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UPhxAnimNotify::GetSourceObject() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAnimNotify", "GetSourceObject");

	Params::PhxAnimNotify_GetSourceObject Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.CharacterState.OnNotifyReceived
// (Final, Native, Public)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterState::OnNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterState", "OnNotifyReceived");

	Params::CharacterState_OnNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterState.OnNotifyStateBeginReceived
// (Final, Native, Public)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterState::OnNotifyStateBeginReceived(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterState", "OnNotifyStateBeginReceived");

	Params::CharacterState_OnNotifyStateBeginReceived Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterState.OnNotifyStateEndReceived
// (Final, Native, Public)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterState::OnNotifyStateEndReceived(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterState", "OnNotifyStateEndReceived");

	Params::CharacterState_OnNotifyStateEndReceived Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterState.GetCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCharacter* UCharacterState::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterState", "GetCharacter");

	Params::CharacterState_GetCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Gadget.GetInteractableComp
// (Final, Native, Public)
// Parameters:
// class UInteractableComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInteractableComponent* AGadget::GetInteractableComp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Gadget", "GetInteractableComp");

	Params::Gadget_GetInteractableComp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Gadget.HandleProximityChanged
// (Native, Protected, BlueprintCallable)
// Parameters:
// EInteractableProximity                  Promity                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInteractableProximity                  PreviousProximity                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AGadget::HandleProximityChanged(EInteractableProximity Promity, EInteractableProximity PreviousProximity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Gadget", "HandleProximityChanged");

	Params::Gadget_HandleProximityChanged Parms{};

	Parms.Promity = Promity;
	Parms.PreviousProximity = PreviousProximity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Gadget.NotifyProximityChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// EInteractableProximity                  Promity                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInteractableProximity                  PreviousProximity                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AGadget::NotifyProximityChanged(EInteractableProximity Promity, EInteractableProximity PreviousProximity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Gadget", "NotifyProximityChanged");

	Params::Gadget_NotifyProximityChanged Parms{};

	Parms.Promity = Promity;
	Parms.PreviousProximity = PreviousProximity;

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


// Function Phoenix.Gadget.GetEnterAnim
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* AGadget::GetEnterAnim() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Gadget", "GetEnterAnim");

	Params::Gadget_GetEnterAnim Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Gadget.GetExitAnim
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* AGadget::GetExitAnim() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Gadget", "GetExitAnim");

	Params::Gadget_GetExitAnim Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Gadget.GetIdleAnim
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* AGadget::GetIdleAnim() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Gadget", "GetIdleAnim");

	Params::Gadget_GetIdleAnim Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Gadget.GetUserCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCharacter* AGadget::GetUserCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Gadget", "GetUserCharacter");

	Params::Gadget_GetUserCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.MicroSwitchboardPuzzle.CheckForPuzzleSuccess
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AMicroSwitchboardPuzzle::CheckForPuzzleSuccess()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicroSwitchboardPuzzle", "CheckForPuzzleSuccess");

	Params::MicroSwitchboardPuzzle_CheckForPuzzleSuccess Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.MicroSwitchboardPuzzle.LeverPulled
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMicroSwitchboardPuzzle::LeverPulled(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicroSwitchboardPuzzle", "LeverPulled");

	Params::MicroSwitchboardPuzzle_LeverPulled Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MicroSwitchboardPuzzle.OnAttemptPowerOn
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bWithCorrectSolution                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMicroSwitchboardPuzzle::OnAttemptPowerOn(bool bWithCorrectSolution)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicroSwitchboardPuzzle", "OnAttemptPowerOn");

	Params::MicroSwitchboardPuzzle_OnAttemptPowerOn Parms{};

	Parms.bWithCorrectSolution = bWithCorrectSolution;

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


// Function Phoenix.MicroSwitchboardPuzzle.OnPlayerEngagedGadget
// (Native, Event, Protected, BlueprintEvent)

void AMicroSwitchboardPuzzle::OnPlayerEngagedGadget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicroSwitchboardPuzzle", "OnPlayerEngagedGadget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MicroSwitchboardPuzzle.OnPlayerLeftGadget
// (Native, Event, Protected, BlueprintEvent)

void AMicroSwitchboardPuzzle::OnPlayerLeftGadget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicroSwitchboardPuzzle", "OnPlayerLeftGadget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MicroSwitchboardPuzzle.IsPuzzleSolved
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AMicroSwitchboardPuzzle::IsPuzzleSolved() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicroSwitchboardPuzzle", "IsPuzzleSolved");

	Params::MicroSwitchboardPuzzle_IsPuzzleSolved Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.AbilityHitReactState.OnAbilityFinished
// (Final, Native, Private)
// Parameters:
// const struct FGameplayTag&              InTag                                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityHitReactState::OnAbilityFinished(const struct FGameplayTag& InTag, int32 NewCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityHitReactState", "OnAbilityFinished");

	Params::AbilityHitReactState_OnAbilityFinished Parms{};

	Parms.InTag = std::move(InTag);
	Parms.NewCount = NewCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.CancelPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UPhxSelectable::CancelPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "CancelPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.ConfirmPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UPhxSelectable::ConfirmPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "ConfirmPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.LocalizeDate
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FDateTime&                 InDateTime                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UPhxSelectable::LocalizeDate(const struct FDateTime& InDateTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "LocalizeDate");

	Params::PhxSelectable_LocalizeDate Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSelectable.SetDisabled
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bIsDisabled                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSelectable::SetDisabled(bool bIsDisabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "SetDisabled");

	Params::PhxSelectable_SetDisabled Parms{};

	Parms.bIsDisabled = bIsDisabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.SetFocused
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bFocused                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSelectable::SetFocused(bool bFocused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "SetFocused");

	Params::PhxSelectable_SetFocused Parms{};

	Parms.bFocused = bFocused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.SetLocked
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bLocked                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSelectable::SetLocked(bool bLocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "SetLocked");

	Params::PhxSelectable_SetLocked Parms{};

	Parms.bLocked = bLocked;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.SetNotificationOn
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bIsOn                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSelectable::SetNotificationOn(bool bIsOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "SetNotificationOn");

	Params::PhxSelectable_SetNotificationOn Parms{};

	Parms.bIsOn = bIsOn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.SetSelected
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bSelected                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSelectable::SetSelected(bool bSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "SetSelected");

	Params::PhxSelectable_SetSelected Parms{};

	Parms.bSelected = bSelected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSelectable.GetMenuReaderTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UPhxSelectable::GetMenuReaderTag() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "GetMenuReaderTag");

	Params::PhxSelectable_GetMenuReaderTag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSelectable.IsFocused
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSelectable::IsFocused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "IsFocused");

	Params::PhxSelectable_IsFocused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSelectable.IsLocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSelectable::IsLocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "IsLocked");

	Params::PhxSelectable_IsLocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSelectable.IsNotificationOn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSelectable::IsNotificationOn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "IsNotificationOn");

	Params::PhxSelectable_IsNotificationOn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSelectable.IsOptionDisabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSelectable::IsOptionDisabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "IsOptionDisabled");

	Params::PhxSelectable_IsOptionDisabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSelectable.IsSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSelectable::IsSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSelectable", "IsSelected");

	Params::PhxSelectable_IsSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxBiosSlot.SetFullBio
// (Event, Public, BlueprintEvent)
// Parameters:
// const class UBiosVirtualData*           BioVID                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxBiosSlot::SetFullBio(const class UBiosVirtualData* BioVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBiosSlot", "SetFullBio");

	Params::PhxBiosSlot_SetFullBio Parms{};

	Parms.BioVID = BioVID;

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


// Function Phoenix.PhxBiosSlot.SetPartialBio
// (Event, Public, BlueprintEvent)
// Parameters:
// const class UBiosVirtualData*           BioVID                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxBiosSlot::SetPartialBio(const class UBiosVirtualData* BioVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBiosSlot", "SetPartialBio");

	Params::PhxBiosSlot_SetPartialBio Parms{};

	Parms.BioVID = BioVID;

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


// Function Phoenix.PhxBlueprintAction_PlayScriptedEvent.PlayScriptedEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxScriptedEventActor*           ScriptedEventActor                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxBlueprintAction_PlayScriptedEvent*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxBlueprintAction_PlayScriptedEvent* UPhxBlueprintAction_PlayScriptedEvent::PlayScriptedEvent(class APhxScriptedEventActor* ScriptedEventActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxBlueprintAction_PlayScriptedEvent", "PlayScriptedEvent");

	Params::PhxBlueprintAction_PlayScriptedEvent_PlayScriptedEvent Parms{};

	Parms.ScriptedEventActor = ScriptedEventActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxBlueprintAction_PlayScriptedEvent.HandleCancel
// (Final, Native, Private)

void UPhxBlueprintAction_PlayScriptedEvent::HandleCancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_PlayScriptedEvent", "HandleCancel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBlueprintAction_PlayScriptedEvent.HandleFail
// (Final, Native, Private)

void UPhxBlueprintAction_PlayScriptedEvent::HandleFail()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_PlayScriptedEvent", "HandleFail");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBlueprintAction_PlayScriptedEvent.HandleFinish
// (Final, Native, Private)

void UPhxBlueprintAction_PlayScriptedEvent::HandleFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_PlayScriptedEvent", "HandleFinish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBlueprintAction_PlayScriptedEvent.HandleNoLevelSequences
// (Final, Native, Private)

void UPhxBlueprintAction_PlayScriptedEvent::HandleNoLevelSequences()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_PlayScriptedEvent", "HandleNoLevelSequences");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBlueprintAction_PlayScriptedEvent.HandleStart
// (Final, Native, Private)

void UPhxBlueprintAction_PlayScriptedEvent::HandleStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_PlayScriptedEvent", "HandleStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSPanel.CancelHeld
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   TimeHeld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::CancelHeld(float TimeHeld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "CancelHeld");

	Params::WSPanel_CancelHeld Parms{};

	Parms.TimeHeld = TimeHeld;

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


// Function Phoenix.WSPanel.CancelPressed
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::CancelPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "CancelPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.CancelReleased
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::CancelReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "CancelReleased");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.Close
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::Close()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "Close");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.ConfirmHeld
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   TimeHeld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::ConfirmHeld(float TimeHeld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "ConfirmHeld");

	Params::WSPanel_ConfirmHeld Parms{};

	Parms.TimeHeld = TimeHeld;

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


// Function Phoenix.WSPanel.ConfirmPressed
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::ConfirmPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "ConfirmPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.ConfirmReleased
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::ConfirmReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "ConfirmReleased");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.FaceLeftHeld
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   TimeHeld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::FaceLeftHeld(float TimeHeld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "FaceLeftHeld");

	Params::WSPanel_FaceLeftHeld Parms{};

	Parms.TimeHeld = TimeHeld;

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


// Function Phoenix.WSPanel.FaceLeftPressed
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::FaceLeftPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "FaceLeftPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.FaceLeftReleased
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::FaceLeftReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "FaceLeftReleased");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.FaceUpHeld
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::FaceUpHeld(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "FaceUpHeld");

	Params::WSPanel_FaceUpHeld Parms{};

	Parms.DeltaTime = DeltaTime;

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


// Function Phoenix.WSPanel.FaceUpPressed
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::FaceUpPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "FaceUpPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.FaceUpReleased
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::FaceUpReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "FaceUpReleased");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.GatherSelectableElements
// (Event, Public, BlueprintEvent)

void AWSPanel::GatherSelectableElements()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GatherSelectableElements");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.HandleDirectionInput
// (Native, Public, BlueprintCallable)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::HandleDirectionInput(EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "HandleDirectionInput");

	Params::WSPanel_HandleDirectionInput Parms{};

	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSPanel.NotifyRefresh
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::NotifyRefresh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "NotifyRefresh");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.Open
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::Open()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "Open");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.PlayGlobalSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    Sound                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::PlayGlobalSound(class UAkAudioEvent* Sound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "PlayGlobalSound");

	Params::WSPanel_PlayGlobalSound Parms{};

	Parms.Sound = Sound;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSPanel.PlaySound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    Sound                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::PlaySound(class UAkAudioEvent* Sound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "PlaySound");

	Params::WSPanel_PlaySound Parms{};

	Parms.Sound = Sound;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSPanel.ReceiveHandleDirectionInput
// (Event, Public, BlueprintEvent)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPanel::ReceiveHandleDirectionInput(EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "ReceiveHandleDirectionInput");

	Params::WSPanel_ReceiveHandleDirectionInput Parms{};

	Parms.Direction = Direction;

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


// Function Phoenix.WSPanel.ShoulderLeftPressed
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::ShoulderLeftPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "ShoulderLeftPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.ShoulderRightPressed
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSPanel::ShoulderRightPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "ShoulderRightPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPanel.GetCancelSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetCancelSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetCancelSound");

	Params::WSPanel_GetCancelSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetCloseSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetCloseSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetCloseSound");

	Params::WSPanel_GetCloseSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetConfirmSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetConfirmSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetConfirmSound");

	Params::WSPanel_GetConfirmSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetDeepestPanel
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class AWSPanel*                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSPanel* AWSPanel::GetDeepestPanel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetDeepestPanel");

	Params::WSPanel_GetDeepestPanel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetNavDownSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetNavDownSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetNavDownSound");

	Params::WSPanel_GetNavDownSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetNavLeftSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetNavLeftSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetNavLeftSound");

	Params::WSPanel_GetNavLeftSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetNavRightSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetNavRightSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetNavRightSound");

	Params::WSPanel_GetNavRightSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetNavUpSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetNavUpSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetNavUpSound");

	Params::WSPanel_GetNavUpSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetOpenSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetOpenSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetOpenSound");

	Params::WSPanel_GetOpenSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetParent
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class AWSPanel*                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSPanel* AWSPanel::GetParent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetParent");

	Params::WSPanel_GetParent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetRelativeOffset
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AWSPanel::GetRelativeOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetRelativeOffset");

	Params::WSPanel_GetRelativeOffset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetRelativeScale
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AWSPanel::GetRelativeScale() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetRelativeScale");

	Params::WSPanel_GetRelativeScale Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetShoulderLeftSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetShoulderLeftSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetShoulderLeftSound");

	Params::WSPanel_GetShoulderLeftSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanel.GetShoulderRightSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AWSPanel::GetShoulderRightSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanel", "GetShoulderRightSound");

	Params::WSPanel_GetShoulderRightSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSkillTree.GatherTreeBranches
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// TArray<class USceneComponent*>*         OutTreeBranches                                        (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AWSSkillTree::GatherTreeBranches(TArray<class USceneComponent*>* OutTreeBranches)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTree", "GatherTreeBranches");

	Params::WSSkillTree_GatherTreeBranches Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function Phoenix.WSSkillTree.GatherTreeSelections
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// TArray<class UChildActorComponent*>*    OutTreeSelections                                      (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AWSSkillTree::GatherTreeSelections(TArray<class UChildActorComponent*>* OutTreeSelections)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTree", "GatherTreeSelections");

	Params::WSSkillTree_GatherTreeSelections Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function Phoenix.WSSkillTree.NotifyHologramUpgrades
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UChildActorComponent*       SelectionComponent                                     (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSkillTree::NotifyHologramUpgrades(const struct FItemData& ItemData, const class UChildActorComponent* SelectionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTree", "NotifyHologramUpgrades");

	Params::WSSkillTree_NotifyHologramUpgrades Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.SelectionComponent = SelectionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSkillTree.NotifyHologramVisibility
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSkillTree::NotifyHologramVisibility(int32 Index_0, bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTree", "NotifyHologramVisibility");

	Params::WSSkillTree_NotifyHologramVisibility Parms{};

	Parms.Index_0 = Index_0;
	Parms.bVisible = bVisible;

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


// Function Phoenix.WSSkillTree.GetCurrentBranchIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AWSSkillTree::GetCurrentBranchIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTree", "GetCurrentBranchIndex");

	Params::WSSkillTree_GetCurrentBranchIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSkillTree.GetSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWSSkillTreeButton*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSSkillTreeButton* AWSSkillTree::GetSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTree", "GetSelected");

	Params::WSSkillTree_GetSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxKeyboardSelectable.SetKeyMapped
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bMapped                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxKeyboardSelectable::SetKeyMapped(bool bMapped)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxKeyboardSelectable", "SetKeyMapped");

	Params::PhxKeyboardSelectable_SetKeyMapped Parms{};

	Parms.bMapped = bMapped;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxKeyboardSelectable.SetKeyValue
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKey&                      KeyValue                                               (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxKeyboardSelectable::SetKeyValue(const struct FKey& KeyValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxKeyboardSelectable", "SetKeyValue");

	Params::PhxKeyboardSelectable_SetKeyValue Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxKeyboardSelectable.IsKeyMapped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxKeyboardSelectable::IsKeyMapped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxKeyboardSelectable", "IsKeyMapped");

	Params::PhxKeyboardSelectable_IsKeyMapped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxKeyboardSelectable.KeyValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UPhxKeyboardSelectable::KeyValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxKeyboardSelectable", "KeyValue");

	Params::PhxKeyboardSelectable_KeyValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.AimState.AimIdle_Begin
// (Final, Native, Protected)
// Parameters:
// const class UStateParams*               Params_0                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAimState::AimIdle_Begin(const class UStateParams* Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "AimIdle_Begin");

	Params::AimState_AimIdle_Begin Parms{};

	Parms.Params_0 = Params_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.AimIdle_End
// (Final, Native, Protected)

void UAimState::AimIdle_End()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "AimIdle_End");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.AuxShoot_Begin
// (Final, Native, Protected)
// Parameters:
// const class UStateParams*               Params_0                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAimState::AuxShoot_Begin(const class UStateParams* Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "AuxShoot_Begin");

	Params::AimState_AuxShoot_Begin Parms{};

	Parms.Params_0 = Params_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.AuxShoot_End
// (Final, Native, Protected)

void UAimState::AuxShoot_End()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "AuxShoot_End");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.Draw_End
// (Final, Native, Protected)

void UAimState::Draw_End()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "Draw_End");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.EnterADS_End
// (Final, Native, Protected)

void UAimState::EnterADS_End()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "EnterADS_End");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.Holster_Begin
// (Final, Native, Protected)

void UAimState::Holster_Begin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "Holster_Begin");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.Shoot_Begin
// (Final, Native, Protected)
// Parameters:
// const class UStateParams*               Params_0                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAimState::Shoot_Begin(const class UStateParams* Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "Shoot_Begin");

	Params::AimState_Shoot_Begin Parms{};

	Parms.Params_0 = Params_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AimState.Shoot_End
// (Final, Native, Protected)

void UAimState::Shoot_End()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AimState", "Shoot_End");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AIPPEResponseState.OnTakeAnyDamage
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIPPEResponseState::OnTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIPPEResponseState", "OnTakeAnyDamage");

	Params::AIPPEResponseState_OnTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioPhysicsComponent.HandleCollisionSounds
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              SelfComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioPhysicsComponent", "HandleCollisionSounds");

	Params::PhxAudioPhysicsComponent_HandleCollisionSounds Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioPhysicsComponent.HandlePointDamage
// (Final, Native, Protected, HasDefaults)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              FHitComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ShotFromDirection                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioPhysicsComponent::HandlePointDamage(class AActor* DamagedActor, float Damage, class AController* InstigatedBy, const struct FVector& HitLocation, class UPrimitiveComponent* FHitComponent, class FName BoneName, const struct FVector& ShotFromDirection, const class UDamageType* DamageType, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioPhysicsComponent", "HandlePointDamage");

	Params::PhxAudioPhysicsComponent_HandlePointDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.InstigatedBy = InstigatedBy;
	Parms.HitLocation = std::move(HitLocation);
	Parms.FHitComponent = FHitComponent;
	Parms.BoneName = BoneName;
	Parms.ShotFromDirection = std::move(ShotFromDirection);
	Parms.DamageType = DamageType;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioPhysicsComponent.OnHitEventDone
// (Final, Native, Private)
// Parameters:
// EAkCallbackType                         CallbackType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  CallbackInfo                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioPhysicsComponent::OnHitEventDone(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioPhysicsComponent", "OnHitEventDone");

	Params::PhxAudioPhysicsComponent_OnHitEventDone Parms{};

	Parms.CallbackType = CallbackType;
	Parms.CallbackInfo = CallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioPhysicsComponent.StopRoll
// (Final, Native, Public)

void UPhxAudioPhysicsComponent::StopRoll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioPhysicsComponent", "StopRoll");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioPhysicsComponent.StopSlide
// (Final, Native, Public)

void UPhxAudioPhysicsComponent::StopSlide()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioPhysicsComponent", "StopSlide");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AmmoDisplay.AttachToWeapon
// (Final, Native, Public)
// Parameters:
// class USceneComponent*                  ParentWeapon                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::AttachToWeapon(class USceneComponent* ParentWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "AttachToWeapon");

	Params::AmmoDisplay_AttachToWeapon Parms{};

	Parms.ParentWeapon = ParentWeapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AmmoDisplay.DetachFromWeapon
// (Final, Native, Public)

void AAmmoDisplay::DetachFromWeapon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "DetachFromWeapon");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AmmoDisplay.OnFadeActivateDisplay
// (Event, Public, BlueprintEvent)

void AAmmoDisplay::OnFadeActivateDisplay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "OnFadeActivateDisplay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.AmmoDisplay.OnFadeDeactivateDisplay
// (Event, Public, BlueprintEvent)

void AAmmoDisplay::OnFadeDeactivateDisplay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "OnFadeDeactivateDisplay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.AmmoDisplay.PlayAmmoChangeSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   AmmoDelta                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewAmmoCount                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::PlayAmmoChangeSound(int32 AmmoDelta, int32 NewAmmoCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "PlayAmmoChangeSound");

	Params::AmmoDisplay_PlayAmmoChangeSound Parms{};

	Parms.AmmoDelta = AmmoDelta;
	Parms.NewAmmoCount = NewAmmoCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AmmoDisplay.SetActiveRounds
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   Rounds                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetActiveRounds(int32 Rounds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetActiveRounds");

	Params::AmmoDisplay_SetActiveRounds Parms{};

	Parms.Rounds = Rounds;

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


// Function Phoenix.AmmoDisplay.SetClipSize
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   ClipSize                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetClipSize(int32 ClipSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetClipSize");

	Params::AmmoDisplay_SetClipSize Parms{};

	Parms.ClipSize = ClipSize;

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


// Function Phoenix.AmmoDisplay.SetCountersVisible
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    Visible                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetCountersVisible(bool Visible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetCountersVisible");

	Params::AmmoDisplay_SetCountersVisible Parms{};

	Parms.Visible = Visible;

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


// Function Phoenix.AmmoDisplay.SetReloadVisible
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    Visible                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetReloadVisible(bool Visible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetReloadVisible");

	Params::AmmoDisplay_SetReloadVisible Parms{};

	Parms.Visible = Visible;

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


// Function Phoenix.AmmoDisplay.SetReserveRounds
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   ReserveRounds                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetReserveRounds(int32 ReserveRounds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetReserveRounds");

	Params::AmmoDisplay_SetReserveRounds Parms{};

	Parms.ReserveRounds = ReserveRounds;

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


// Function Phoenix.AmmoDisplay.SetSecondaryRounds
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   Rounds                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetSecondaryRounds(int32 Rounds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetSecondaryRounds");

	Params::AmmoDisplay_SetSecondaryRounds Parms{};

	Parms.Rounds = Rounds;

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


// Function Phoenix.AmmoDisplay.SetSecondaryUnlocked
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    Active                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetSecondaryUnlocked(bool Active)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetSecondaryUnlocked");

	Params::AmmoDisplay_SetSecondaryUnlocked Parms{};

	Parms.Active = Active;

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


// Function Phoenix.AmmoDisplay.SetUpgradeVisuals
// (Event, Public, BlueprintEvent)

void AAmmoDisplay::SetUpgradeVisuals()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetUpgradeVisuals");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.AmmoDisplay.SetVisible
// (Final, Native, Public)
// Parameters:
// bool                                    Visible                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAmmoDisplay::SetVisible(bool Visible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoDisplay", "SetVisible");

	Params::AmmoDisplay_SetVisible Parms{};

	Parms.Visible = Visible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterDynMatPropagator.OnPlayerSkinChanged
// (Final, Native, Public)
// Parameters:
// class UPhxCharacterSkin*                NewSkin                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterDynMatPropagator::OnPlayerSkinChanged(class UPhxCharacterSkin* NewSkin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterDynMatPropagator", "OnPlayerSkinChanged");

	Params::PhxCharacterDynMatPropagator_OnPlayerSkinChanged Parms{};

	Parms.NewSkin = NewSkin;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterDynMatPropagator.PropagateDynamicMaterials
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterDynMatPropagator::PropagateDynamicMaterials()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterDynMatPropagator", "PropagateDynamicMaterials");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterDynMatPropagator.SetMaterialByNameDoNotPropagate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             MaterialSlotName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInterface*               Material                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterDynMatPropagator::SetMaterialByNameDoNotPropagate(class FName MaterialSlotName, class UMaterialInterface* Material)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterDynMatPropagator", "SetMaterialByNameDoNotPropagate");

	Params::PhxCharacterDynMatPropagator_SetMaterialByNameDoNotPropagate Parms{};

	Parms.MaterialSlotName = MaterialSlotName;
	Parms.Material = Material;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterDynMatPropagator.SetMaterialDoNotPropagate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ElementIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInterface*               Material                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterDynMatPropagator::SetMaterialDoNotPropagate(int32 ElementIndex, class UMaterialInterface* Material)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterDynMatPropagator", "SetMaterialDoNotPropagate");

	Params::PhxCharacterDynMatPropagator_SetMaterialDoNotPropagate Parms{};

	Parms.ElementIndex = ElementIndex;
	Parms.Material = Material;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.DevMenuLibrary.GetDevFunctionColor
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// const class FString&                    FuncName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FLinearColor ADevMenuLibrary::GetDevFunctionColor(const class FString& FuncName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DevMenuLibrary", "GetDevFunctionColor");

	Params::DevMenuLibrary_GetDevFunctionColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.DevMenuLibrary.GetDevFunctionNameSuffix
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class FString&                    FuncName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ADevMenuLibrary::GetDevFunctionNameSuffix(const class FString& FuncName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DevMenuLibrary", "GetDevFunctionNameSuffix");

	Params::DevMenuLibrary_GetDevFunctionNameSuffix Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.DevMenuLibrary.GetIntCVarMenuColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    CVarName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FLinearColor ADevMenuLibrary::GetIntCVarMenuColor(const class FString& CVarName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DevMenuLibrary", "GetIntCVarMenuColor");

	Params::DevMenuLibrary_GetIntCVarMenuColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HologramPanelComponent.GetDynamicMaterial
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UMaterialInstanceDynamic*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UHologramPanelComponent::GetDynamicMaterial()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPanelComponent", "GetDynamicMaterial");

	Params::HologramPanelComponent_GetDynamicMaterial Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HologramPanelComponent.OnDeactivationCompleted
// (Final, Native, Protected)

void UHologramPanelComponent::OnDeactivationCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPanelComponent", "OnDeactivationCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HologramPanelComponent.UpdateRotation
// (Final, Native, Protected)
// Parameters:
// float                                   Output                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHologramPanelComponent::UpdateRotation(float Output)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPanelComponent", "UpdateRotation");

	Params::HologramPanelComponent_UpdateRotation Parms{};

	Parms.Output = Output;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HologramPanelComponent.UpdateScaleAndIntensity
// (Final, Native, Protected)
// Parameters:
// float                                   Output                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHologramPanelComponent::UpdateScaleAndIntensity(float Output)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPanelComponent", "UpdateScaleAndIntensity");

	Params::HologramPanelComponent_UpdateScaleAndIntensity Parms{};

	Parms.Output = Output;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDecalLightFixture.InitializeDecalLightFixture
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxDecalLightFixture::InitializeDecalLightFixture()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDecalLightFixture", "InitializeDecalLightFixture");

	Params::PhxDecalLightFixture_InitializeDecalLightFixture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDecalLightFixture.UpdateFlickerTimelineFunc
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   OutputFlickerPattern                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDecalLightFixture::UpdateFlickerTimelineFunc(float OutputFlickerPattern)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDecalLightFixture", "UpdateFlickerTimelineFunc");

	Params::PhxDecalLightFixture_UpdateFlickerTimelineFunc Parms{};

	Parms.OutputFlickerPattern = OutputFlickerPattern;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleActorOverlapBeginTrigger
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleActorOverlapBeginTrigger(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleActorOverlapBeginTrigger");

	Params::PhxAIEncounterGroup_HandleActorOverlapBeginTrigger Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleActorOverlapDespawnTrigger
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleActorOverlapDespawnTrigger(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleActorOverlapDespawnTrigger");

	Params::PhxAIEncounterGroup_HandleActorOverlapDespawnTrigger Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleAIDestroyed
// (Native, Protected)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleAIDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleAIDestroyed");

	Params::PhxAIEncounterGroup_HandleAIDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleAIDied
// (Native, Protected)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleAIDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleAIDied");

	Params::PhxAIEncounterGroup_HandleAIDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleAILimboBegin
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    CharacterInLimbo                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleAILimboBegin(class APhxCharacter* CharacterInLimbo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleAILimboBegin");

	Params::PhxAIEncounterGroup_HandleAILimboBegin Parms{};

	Parms.CharacterInLimbo = CharacterInLimbo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleAILimboEnd
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    CharacterInLimbo                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleAILimboEnd(class APhxCharacter* CharacterInLimbo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleAILimboEnd");

	Params::PhxAIEncounterGroup_HandleAILimboEnd Parms{};

	Parms.CharacterInLimbo = CharacterInLimbo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleAISpawned
// (Native, Protected)
// Parameters:
// class APhxAICharacter*                  SpawnedAI                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAISpawnResultCode                   ResultCode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SpawnUid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleAISpawned(class APhxAICharacter* SpawnedAI, EPhxAISpawnResultCode ResultCode, int32 SpawnUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleAISpawned");

	Params::PhxAIEncounterGroup_HandleAISpawned Parms{};

	Parms.SpawnedAI = SpawnedAI;
	Parms.ResultCode = ResultCode;
	Parms.SpawnUid = SpawnUid;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.HandleAITakeAnyDamage
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterGroup::HandleAITakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "HandleAITakeAnyDamage");

	Params::PhxAIEncounterGroup_HandleAITakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.ResetEncounterGroup
// (Native, Public, BlueprintCallable)

void APhxAIEncounterGroup::ResetEncounterGroup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "ResetEncounterGroup");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroup.GetAliveAIByCharacterTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             CharacterTag                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacter* APhxAIEncounterGroup::GetAliveAIByCharacterTag(class FName CharacterTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "GetAliveAIByCharacterTag");

	Params::PhxAIEncounterGroup_GetAliveAIByCharacterTag Parms{};

	Parms.CharacterTag = CharacterTag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroup.GetAllAliveAI_BP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class APhxAICharacter*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class APhxAICharacter*> APhxAIEncounterGroup::GetAllAliveAI_BP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "GetAllAliveAI_BP");

	Params::PhxAIEncounterGroup_GetAllAliveAI_BP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroup.GetAllAliveAIForWave_BP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class APhxAICharacter*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class APhxAICharacter*> APhxAIEncounterGroup::GetAllAliveAIForWave_BP(class FName Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "GetAllAliveAIForWave_BP");

	Params::PhxAIEncounterGroup_GetAllAliveAIForWave_BP Parms{};

	Parms.Tag = Tag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroup.GetNumAliveAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxAIEncounterGroup::GetNumAliveAI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "GetNumAliveAI");

	Params::PhxAIEncounterGroup_GetNumAliveAI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroup.GetNumAliveAIForWave
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxAIEncounterGroup::GetNumAliveAIForWave(class FName Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "GetNumAliveAIForWave");

	Params::PhxAIEncounterGroup_GetNumAliveAIForWave Parms{};

	Parms.Tag = Tag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroup.GetWaveDescriptor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIEncounterGroupWaveDescriptor*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIEncounterGroupWaveDescriptor* APhxAIEncounterGroup::GetWaveDescriptor(class FName Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroup", "GetWaveDescriptor");

	Params::PhxAIEncounterGroup_GetWaveDescriptor Parms{};

	Parms.Tag = Tag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIHordeEncounterGroup.AuditSpawners
// (Final, Native, Protected)

void APhxAIHordeEncounterGroup::AuditSpawners()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "AuditSpawners");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIHordeEncounterGroup.GetAITypeAndCountForCurrentWave
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   InHordeWaveIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<struct FGameplayTag, int32>*       OutAITypeAndCountMap                                   (Parm, OutParm, NativeAccessSpecifierPublic)
// int32*                                  OutTotalAICountForWave                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIHordeEncounterGroup::GetAITypeAndCountForCurrentWave(int32 InHordeWaveIndex, TMap<struct FGameplayTag, int32>* OutAITypeAndCountMap, int32* OutTotalAICountForWave)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "GetAITypeAndCountForCurrentWave");

	Params::PhxAIHordeEncounterGroup_GetAITypeAndCountForCurrentWave Parms{};

	Parms.InHordeWaveIndex = InHordeWaveIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxAIHordeEncounterGroup.GetNumAIRemainingInActiveWave
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxAIHordeEncounterGroup::GetNumAIRemainingInActiveWave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "GetNumAIRemainingInActiveWave");

	Params::PhxAIHordeEncounterGroup_GetNumAIRemainingInActiveWave Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIHordeEncounterGroup.GetNumAIRemainingInWave
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   WaveIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxAIHordeEncounterGroup::GetNumAIRemainingInWave(int32 WaveIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "GetNumAIRemainingInWave");

	Params::PhxAIHordeEncounterGroup_GetNumAIRemainingInWave Parms{};

	Parms.WaveIndex = WaveIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIHordeEncounterGroup.KillAIByCount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   NumAIToKill                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIHordeEncounterGroup::KillAIByCount(int32 NumAIToKill)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "KillAIByCount");

	Params::PhxAIHordeEncounterGroup_KillAIByCount Parms{};

	Parms.NumAIToKill = NumAIToKill;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIHordeEncounterGroup.SetSafeRoomActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInSafeRoomActive                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIHordeEncounterGroup::SetSafeRoomActive(bool bInSafeRoomActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "SetSafeRoomActive");

	Params::PhxAIHordeEncounterGroup_SetSafeRoomActive Parms{};

	Parms.bInSafeRoomActive = bInSafeRoomActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIHordeEncounterGroup.SyncSpawners
// (Final, Native, Protected)

void APhxAIHordeEncounterGroup::SyncSpawners()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "SyncSpawners");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIHordeEncounterGroup.GetWaveSpawnDelay
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   InHordeWaveIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxAIHordeEncounterGroup::GetWaveSpawnDelay(int32 InHordeWaveIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHordeEncounterGroup", "GetWaveSpawnDelay");

	Params::PhxAIHordeEncounterGroup_GetWaveSpawnDelay Parms{};

	Parms.InHordeWaveIndex = InHordeWaveIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSScreenWidget.OnRemovedFromViewport
// (Event, Public, BlueprintEvent)

void USDSScreenWidget::OnRemovedFromViewport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSScreenWidget", "OnRemovedFromViewport");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.SDSScreenWidget.SetBreadcrumb
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FText&                      InCrumb                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSScreenWidget::SetBreadcrumb(const class FText& InCrumb)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSScreenWidget", "SetBreadcrumb");

	Params::SDSScreenWidget_SetBreadcrumb Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSScreenWidget.SetSequenceScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSoftClassPtr<class UClass>             InSequenceScreen                                       (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSScreenWidget::SetSequenceScreen(TSoftClassPtr<class UClass> InSequenceScreen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSScreenWidget", "SetSequenceScreen");

	Params::SDSScreenWidget_SetSequenceScreen Parms{};

	Parms.InSequenceScreen = InSequenceScreen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSScreenWidget.Setup
// (Native, Event, Public, BlueprintEvent)

void USDSScreenWidget::Setup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSScreenWidget", "Setup");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSScreenWidget.SetUserUserParameter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InUserParameter                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSScreenWidget::SetUserUserParameter(const class FString& InUserParameter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSScreenWidget", "SetUserUserParameter");

	Params::SDSScreenWidget_SetUserUserParameter Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSMenuWidget.GetAdjacent
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UPhxSelectable*             Target                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputDirection                   Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSelectable*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSelectable* USDSMenuWidget::GetAdjacent(const class UPhxSelectable* Target, const EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSMenuWidget", "GetAdjacent");

	Params::SDSMenuWidget_GetAdjacent Parms{};

	Parms.Target = Target;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSMenuWidget.HandleBackgroundVisibility
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)

void USDSMenuWidget::HandleBackgroundVisibility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSMenuWidget", "HandleBackgroundVisibility");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSMenuWidget.NotifySelectionChange
// (Final, Native, Public, BlueprintCallable)

void USDSMenuWidget::NotifySelectionChange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSMenuWidget", "NotifySelectionChange");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSMenuWidget.PlayGlobalSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UAkAudioEvent*              Sound                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSMenuWidget::PlayGlobalSound(const class UAkAudioEvent* Sound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSMenuWidget", "PlayGlobalSound");

	Params::SDSMenuWidget_PlayGlobalSound Parms{};

	Parms.Sound = Sound;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSMenuWidget.SelectFirstAvailable
// (Final, Native, Public, BlueprintCallable)

void USDSMenuWidget::SelectFirstAvailable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSMenuWidget", "SelectFirstAvailable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSMenuWidget.UpdateSelected
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxSelectable*                   Selected                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSMenuWidget::UpdateSelected(class UPhxSelectable* Selected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSMenuWidget", "UpdateSelected");

	Params::SDSMenuWidget_UpdateSelected Parms{};

	Parms.Selected = Selected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSMenuWidget.GetSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxSelectable*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSelectable* USDSMenuWidget::GetSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSMenuWidget", "GetSelected");

	Params::SDSMenuWidget_GetSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GammaScreenWidget.SetSliderPosition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBroadcast                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGammaScreenWidget::SetSliderPosition(float InValue, bool bBroadcast)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GammaScreenWidget", "SetSliderPosition");

	Params::GammaScreenWidget_SetSliderPosition Parms{};

	Parms.InValue = InValue;
	Parms.bBroadcast = bBroadcast;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Pickup.OnActorRestored
// (Native, Protected)

void APickup::OnActorRestored()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Pickup", "OnActorRestored");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Pickup.CanPickup
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class APhxCharacter*              Picker                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickup::CanPickup(const class APhxCharacter* Picker) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Pickup", "CanPickup");

	Params::Pickup_CanPickup Parms{};

	Parms.Picker = Picker;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Pickup.GetItemData
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData                  ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FItemData APickup::GetItemData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Pickup", "GetItemData");

	Params::Pickup_GetItemData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Pickup.GetPickupSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APickup::GetPickupSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Pickup", "GetPickupSound");

	Params::Pickup_GetPickupSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Pickup.GetVirtualItemData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UVirtualItemData*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UVirtualItemData* APickup::GetVirtualItemData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Pickup", "GetVirtualItemData");

	Params::Pickup_GetVirtualItemData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Equippable.GetDiscardThenEquipAnimation
// (Final, Native, Public)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* AEquippable::GetDiscardThenEquipAnimation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "GetDiscardThenEquipAnimation");

	Params::Equippable_GetDiscardThenEquipAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Equippable.HideEquipment
// (Native, Public, BlueprintCallable)

void AEquippable::HideEquipment()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "HideEquipment");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Equippable.OnEquipBegin
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bInstant                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEquippable::OnEquipBegin(bool bInstant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "OnEquipBegin");

	Params::Equippable_OnEquipBegin Parms{};

	Parms.bInstant = bInstant;

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


// Function Phoenix.Equippable.OnEquipInterrupted
// (Event, Public, BlueprintEvent)

void AEquippable::OnEquipInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "OnEquipInterrupted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.Equippable.OnEquipped
// (Event, Protected, BlueprintEvent)

void AEquippable::OnEquipped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "OnEquipped");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.Equippable.OnUnequipBegin
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bInstant                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEquippable::OnUnequipBegin(bool bInstant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "OnUnequipBegin");

	Params::Equippable_OnUnequipBegin Parms{};

	Parms.bInstant = bInstant;

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


// Function Phoenix.Equippable.OnUnequipped
// (Event, Protected, BlueprintEvent)

void AEquippable::OnUnequipped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "OnUnequipped");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.Equippable.ShowEquipment
// (Native, Public, BlueprintCallable)

void AEquippable::ShowEquipment()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "ShowEquipment");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Equippable.TurnOffSkelMeshUpdate
// (Final, Native, Public)

void AEquippable::TurnOffSkelMeshUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "TurnOffSkelMeshUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Equippable.GetEquipAnimation
// (Final, Native, Public, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* AEquippable::GetEquipAnimation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "GetEquipAnimation");

	Params::Equippable_GetEquipAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Equippable.GetEquipSound
// (Final, Native, Public, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AEquippable::GetEquipSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "GetEquipSound");

	Params::Equippable_GetEquipSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Equippable.GetHolsterAnimation
// (Final, Native, Public, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* AEquippable::GetHolsterAnimation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "GetHolsterAnimation");

	Params::Equippable_GetHolsterAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Equippable.GetHolsterSound
// (Final, Native, Public, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* AEquippable::GetHolsterSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "GetHolsterSound");

	Params::Equippable_GetHolsterSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Equippable.GetMeshComponent
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class UMeshComponent*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMeshComponent* AEquippable::GetMeshComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Equippable", "GetMeshComponent");

	Params::Equippable_GetMeshComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Weapon.GetCurrentMaterialSlotsVisibility
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<bool>*                           OutSlotsVisibility                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AWeapon::GetCurrentMaterialSlotsVisibility(TArray<bool>* OutSlotsVisibility) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Weapon", "GetCurrentMaterialSlotsVisibility");

	Params::Weapon_GetCurrentMaterialSlotsVisibility Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.Weapon.GetMaterialSlotsVisibilityWithUpgrades
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<bool>*                           OutSlotsVisibility                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AWeapon::GetMaterialSlotsVisibilityWithUpgrades(TArray<bool>* OutSlotsVisibility) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Weapon", "GetMaterialSlotsVisibilityWithUpgrades");

	Params::Weapon_GetMaterialSlotsVisibilityWithUpgrades Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.Weapon.GetMeshComp
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* AWeapon::GetMeshComp() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Weapon", "GetMeshComp");

	Params::Weapon_GetMeshComp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Weapon.GetUpgradeComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxUpgradeComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxUpgradeComponent* AWeapon::GetUpgradeComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Weapon", "GetUpgradeComponent");

	Params::Weapon_GetUpgradeComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Weapon.GetWeaponTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayTag AWeapon::GetWeaponTag() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Weapon", "GetWeaponTag");

	Params::Weapon_GetWeaponTag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.MeleeWeapon.OnEquipTagRemoved
// (Final, Native, Protected)
// Parameters:
// const struct FGameplayTag&              InTag                                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMeleeWeapon::OnEquipTagRemoved(const struct FGameplayTag& InTag, int32 NewCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MeleeWeapon", "OnEquipTagRemoved");

	Params::MeleeWeapon_OnEquipTagRemoved Parms{};

	Parms.InTag = std::move(InTag);
	Parms.NewCount = NewCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MeleeWeapon.OnGroundSlamHit
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   HitLocation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMeleeWeapon::OnGroundSlamHit(const struct FVector& HitLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MeleeWeapon", "OnGroundSlamHit");

	Params::MeleeWeapon_OnGroundSlamHit Parms{};

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

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


// Function Phoenix.MeleeWeapon.OnWeaponHit
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const class AActor*                     HitActor                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ImpactLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsChargedAttack                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsHeavyAttack                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDisableImpactFX                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMeleeWeapon::OnWeaponHit(const class AActor* HitActor, const struct FVector& ImpactLocation, bool bIsChargedAttack, bool bIsHeavyAttack, bool bDisableImpactFX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MeleeWeapon", "OnWeaponHit");

	Params::MeleeWeapon_OnWeaponHit Parms{};

	Parms.HitActor = HitActor;
	Parms.ImpactLocation = std::move(ImpactLocation);
	Parms.bIsChargedAttack = bIsChargedAttack;
	Parms.bIsHeavyAttack = bIsHeavyAttack;
	Parms.bDisableImpactFX = bDisableImpactFX;

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


// Function Phoenix.MeleeAttackState.OnTargetDefensiveReactionInputEnded
// (Final, Native, Protected)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMeleeAttackState::OnTargetDefensiveReactionInputEnded(EReactionType ReactionType, EDefensiveReactDirection ReactionDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MeleeAttackState", "OnTargetDefensiveReactionInputEnded");

	Params::MeleeAttackState_OnTargetDefensiveReactionInputEnded Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MeleeAttackState.OnTargetDefensiveReactionInputStarted
// (Final, Native, Protected)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMeleeAttackState::OnTargetDefensiveReactionInputStarted(EReactionType ReactionType, EDefensiveReactDirection ReactionDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MeleeAttackState", "OnTargetDefensiveReactionInputStarted");

	Params::MeleeAttackState_OnTargetDefensiveReactionInputStarted Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.BloodwormParryState.ReceiveQteCompletion
// (Final, Native, Private)
// Parameters:
// class FName                             InQteId                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInResult                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBloodwormParryState::ReceiveQteCompletion(class FName InQteId, bool bInResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BloodwormParryState", "ReceiveQteCompletion");

	Params::BloodwormParryState_ReceiveQteCompletion Parms{};

	Parms.InQteId = InQteId;
	Parms.bInResult = bInResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GlowBlob.OnPerceived
// (Final, Native, Private)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAIStimulus&               Stimulus                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)

void AGlowBlob::OnPerceived(class AActor* Actor, const struct FAIStimulus& Stimulus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GlowBlob", "OnPerceived");

	Params::GlowBlob_OnPerceived Parms{};

	Parms.Actor = Actor;
	Parms.Stimulus = std::move(Stimulus);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EnvironmentalHazard.BP_OnTriggered
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    EnemyCharacter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                OverlapResult                                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AEnvironmentalHazard::BP_OnTriggered(class APhxCharacter* EnemyCharacter, class UPrimitiveComponent* OverlappedComponent, const struct FHitResult& OverlapResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard", "BP_OnTriggered");

	Params::EnvironmentalHazard_BP_OnTriggered Parms{};

	Parms.EnemyCharacter = EnemyCharacter;
	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OverlapResult = std::move(OverlapResult);

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


// Function Phoenix.EnvironmentalHazard.BP_SwitchedOff
// (Event, Public, BlueprintEvent)

void AEnvironmentalHazard::BP_SwitchedOff()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard", "BP_SwitchedOff");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.EnvironmentalHazard.BP_SwitchedOn
// (Event, Public, BlueprintEvent)

void AEnvironmentalHazard::BP_SwitchedOn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard", "BP_SwitchedOn");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.EnvironmentalHazard.OnOverlapDetected
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AEnvironmentalHazard::OnOverlapDetected(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard", "OnOverlapDetected");

	Params::EnvironmentalHazard_OnOverlapDetected Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EnvironmentalHazard.SetActive
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bOn                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEnvironmentalHazard::SetActive(bool bOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard", "SetActive");

	Params::EnvironmentalHazard_SetActive Parms{};

	Parms.bOn = bOn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EnvironmentalHazard.IsSwitchedOn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEnvironmentalHazard::IsSwitchedOn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard", "IsSwitchedOn");

	Params::EnvironmentalHazard_IsSwitchedOn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallCollisionBoxExtent
// (Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEnvironmentalHazard_SpikeWall::GetWallCollisionBoxExtent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard_SpikeWall", "GetWallCollisionBoxExtent");

	Params::EnvironmentalHazard_SpikeWall_GetWallCollisionBoxExtent Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallCollisionComponentLocation
// (Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEnvironmentalHazard_SpikeWall::GetWallCollisionComponentLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard_SpikeWall", "GetWallCollisionComponentLocation");

	Params::EnvironmentalHazard_SpikeWall_GetWallCollisionComponentLocation Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallSpikeForward
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEnvironmentalHazard_SpikeWall::GetWallSpikeForward() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard_SpikeWall", "GetWallSpikeForward");

	Params::EnvironmentalHazard_SpikeWall_GetWallSpikeForward Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.EnvironmentalHazard_SpikeWall.GetWallSpikeRight
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEnvironmentalHazard_SpikeWall::GetWallSpikeRight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard_SpikeWall", "GetWallSpikeRight");

	Params::EnvironmentalHazard_SpikeWall_GetWallSpikeRight Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMenuWidget.OnConstruct
// (Native, Protected, BlueprintCallable)

void UPhxMenuWidget::OnConstruct()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenuWidget", "OnConstruct");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMenuWidget.GetWidgetMenuButtons
// (Final, Native, Public, Const)
// Parameters:
// const TArray<class UMenuButton*>        ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

const TArray<class UMenuButton*> UPhxMenuWidget::GetWidgetMenuButtons() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenuWidget", "GetWidgetMenuButtons");

	Params::PhxMenuWidget_GetWidgetMenuButtons Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIProp.TryTrigger
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Triggerer                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              TriggerType                                            (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxAIProp::TryTrigger(class AActor* Triggerer, const struct FGameplayTag& TriggerType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIProp", "TryTrigger");

	Params::PhxAIProp_TryTrigger Parms{};

	Parms.Triggerer = Triggerer;
	Parms.TriggerType = std::move(TriggerType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIProp.GetTriggerType
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class AActor*                           Triggerer                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              TriggerType                                            (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayTag APhxAIProp::GetTriggerType(class AActor* Triggerer, const struct FGameplayTag& TriggerType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIProp", "GetTriggerType");

	Params::PhxAIProp_GetTriggerType Parms{};

	Parms.Triggerer = Triggerer;
	Parms.TriggerType = std::move(TriggerType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAnnouncer.PlayAnnouncementOverhead
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAnnouncer::PlayAnnouncementOverhead(class UObject* WorldContextObject, class UAkAudioEvent* Event)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAnnouncer", "PlayAnnouncementOverhead");

	Params::PhxAnnouncer_PlayAnnouncementOverhead Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Event = Event;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PlayerControllerState.GetCharacter
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxPlayerCharacter*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxPlayerCharacter* UPlayerControllerState::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerControllerState", "GetCharacter");

	Params::PlayerControllerState_GetCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryMainStateBase.HandleGameplayTagCallback
// (Final, Native, Protected)
// Parameters:
// const struct FGameplayTag&              InTag                                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryMainStateBase::HandleGameplayTagCallback(const struct FGameplayTag& InTag, int32 NewCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryMainStateBase", "HandleGameplayTagCallback");

	Params::InventoryMainStateBase_HandleGameplayTagCallback Parms{};

	Parms.InTag = std::move(InTag);
	Parms.NewCount = NewCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Interaction.GetHighestPriorityInteraction
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<TSubclassOf<class UInteraction>>&Interactions                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
// TSubclassOf<class UInteraction>         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UInteraction> UInteraction::GetHighestPriorityInteraction(const TArray<TSubclassOf<class UInteraction>>& Interactions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("Interaction", "GetHighestPriorityInteraction");

	Params::Interaction_GetHighestPriorityInteraction Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Interaction.Intersects
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<TSubclassOf<class UInteraction>>&A                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
// const TArray<TSubclassOf<class UInteraction>>&B                                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
// TArray<TSubclassOf<class UInteraction>>*Intersection                                           (Parm, OutParm, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteraction::Intersects(const TArray<TSubclassOf<class UInteraction>>& A, const TArray<TSubclassOf<class UInteraction>>& B, TArray<TSubclassOf<class UInteraction>>* Intersection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("Interaction", "Intersects");

	Params::Interaction_Intersects Parms{};

	Parms.A = std::move(A);
	Parms.B = std::move(B);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.Interaction.Initialize
// (Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                            NewSource                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInteractableComponent*           NewTarget                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteraction::Initialize(class APawn* NewSource, class UInteractableComponent* NewTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "Initialize");

	Params::Interaction_Initialize Parms{};

	Parms.NewSource = NewSource;
	Parms.NewTarget = NewTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Interaction.BlueprintOnExecute
// (Event, Protected, BlueprintEvent, Const)

void UInteraction::BlueprintOnExecute() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "BlueprintOnExecute");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.Interaction.GetSource
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APawn* UInteraction::GetSource() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "GetSource");

	Params::Interaction_GetSource Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Interaction.GetSourceToTargetTransformation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UInteraction::GetSourceToTargetTransformation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "GetSourceToTargetTransformation");

	Params::Interaction_GetSourceToTargetTransformation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Interaction.GetSourceTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UInteraction::GetSourceTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "GetSourceTransform");

	Params::Interaction_GetSourceTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Interaction.GetTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInteractableComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInteractableComponent* UInteraction::GetTarget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "GetTarget");

	Params::Interaction_GetTarget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Interaction.GetTargetActorTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UInteraction::GetTargetActorTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "GetTargetActorTransform");

	Params::Interaction_GetTargetActorTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Interaction.GetTargetTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UInteraction::GetTargetTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Interaction", "GetTargetTransform");

	Params::Interaction_GetTargetTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.TrackFollower.SetStartingPointToCurrentLocation
// (Final, Native, Protected)

void ATrackFollower::SetStartingPointToCurrentLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TrackFollower", "SetStartingPointToCurrentLocation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TrackFollower.SnapToSpline
// (Final, Native, Public)

void ATrackFollower::SnapToSpline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TrackFollower", "SnapToSpline");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TrackFollower.GetCurrentSplineLocation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ATrackFollower::GetCurrentSplineLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TrackFollower", "GetCurrentSplineLocation");

	Params::TrackFollower_GetCurrentSplineLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventorySlot.ApplyVID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UVirtualItemData*           InVID                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventorySlot::ApplyVID(const class UVirtualItemData* InVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "ApplyVID");

	Params::InventorySlot_ApplyVID Parms{};

	Parms.InVID = InVID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventorySlot.ClearItem
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UInventorySlot::ClearItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "ClearItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventorySlot.NotifyActionDenied
// (Event, Public, BlueprintEvent)

void UInventorySlot::NotifyActionDenied()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "NotifyActionDenied");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.InventorySlot.NotifyConfirmHeld
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   TimeHeld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventorySlot::NotifyConfirmHeld(float TimeHeld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "NotifyConfirmHeld");

	Params::InventorySlot_NotifyConfirmHeld Parms{};

	Parms.TimeHeld = TimeHeld;

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


// Function Phoenix.InventorySlot.SetItem
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UInventorySlot::SetItem(const struct FItemData& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "SetItem");

	Params::InventorySlot_SetItem Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventorySlot.GetCachedItemData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData                  ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FItemData UInventorySlot::GetCachedItemData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "GetCachedItemData");

	Params::InventorySlot_GetCachedItemData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventorySlot.IsBreadcrumbActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventorySlot::IsBreadcrumbActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "IsBreadcrumbActive");

	Params::InventorySlot_IsBreadcrumbActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventorySlot.IsNavigationBlocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventorySlot::IsNavigationBlocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "IsNavigationBlocked");

	Params::InventorySlot_IsNavigationBlocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventorySlot.IsOccupied
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventorySlot::IsOccupied() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventorySlot", "IsOccupied");

	Params::InventorySlot_IsOccupied Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility.EndAbility_Internal
// (Final, Native, Protected)
// Parameters:
// bool                                    bRemoveAbility                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCancel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility::EndAbility_Internal(bool bRemoveAbility, bool bCancel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility", "EndAbility_Internal");

	Params::PhxGameplayAbility_EndAbility_Internal Parms{};

	Parms.bRemoveAbility = bRemoveAbility;
	Parms.bCancel = bCancel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility.IsTaskActive
// (Final, Native, Public)
// Parameters:
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayAbility::IsTaskActive(class FName TaskInstanceName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility", "IsTaskActive");

	Params::PhxGameplayAbility_IsTaskActive Parms{};

	Parms.TaskInstanceName = TaskInstanceName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility.OnEarlyExitAllowed
// (Final, Native, Private)

void UPhxGameplayAbility::OnEarlyExitAllowed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility", "OnEarlyExitAllowed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Parasite_Leap.OnEnemyHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Parasite_Leap", "OnEnemyHit");

	Params::PhxAIGameplayAbility_Parasite_Leap_OnEnemyHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Parasite_Leap.OnLandingMontageCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Parasite_Leap::OnLandingMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Parasite_Leap", "OnLandingMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Parasite_Leap.OnLeapMontageCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Parasite_Leap::OnLeapMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Parasite_Leap", "OnLeapMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Parasite_Leap.OnLeapMoveTaskCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Parasite_Leap::OnLeapMoveTaskCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Parasite_Leap", "OnLeapMoveTaskCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GlowManager.OnPerceived
// (Final, Native, Private)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAIStimulus&               Stimulus                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)

void AGlowManager::OnPerceived(class AActor* Actor, const struct FAIStimulus& Stimulus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GlowManager", "OnPerceived");

	Params::GlowManager_OnPerceived Parms{};

	Parms.Actor = Actor;
	Parms.Stimulus = std::move(Stimulus);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISensor_Hearing.MakeAISoundEvent
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           SourceActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Instigator                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAISoundLoudness                     SoundLoudness                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   OverrideSoundLocation                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MaxReceivers                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISensor_Hearing::MakeAISoundEvent(class UObject* WorldContextObject, class AActor* SourceActor, class AActor* Instigator, EPhxAISoundLoudness SoundLoudness, const struct FVector& OverrideSoundLocation, int32 MaxReceivers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAISensor_Hearing", "MakeAISoundEvent");

	Params::PhxAISensor_Hearing_MakeAISoundEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SourceActor = SourceActor;
	Parms.Instigator = Instigator;
	Parms.SoundLoudness = SoundLoudness;
	Parms.OverrideSoundLocation = std::move(OverrideSoundLocation);
	Parms.MaxReceivers = MaxReceivers;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMenu.HandleOnlineAccount
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class USDSOnlineAccount*          OnlineAccount                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMenu::HandleOnlineAccount(const class USDSOnlineAccount* OnlineAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenu", "HandleOnlineAccount");

	Params::PhxMenu_HandleOnlineAccount Parms{};

	Parms.OnlineAccount = OnlineAccount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMenu.NotifyAuthRequest
// (Event, Public, BlueprintEvent)

void UPhxMenu::NotifyAuthRequest()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenu", "NotifyAuthRequest");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMenu.NotifyUserOnline
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bIsConnected                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USDSOnlineAccount*          OnlineAccount                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMenu::NotifyUserOnline(bool bIsConnected, const class USDSOnlineAccount* OnlineAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenu", "NotifyUserOnline");

	Params::PhxMenu_NotifyUserOnline Parms{};

	Parms.bIsConnected = bIsConnected;
	Parms.OnlineAccount = OnlineAccount;

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


// Function Phoenix.PhxMenu.GetSelectedElement
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxSelectable*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSelectable* UPhxMenu::GetSelectedElement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenu", "GetSelectedElement");

	Params::PhxMenu_GetSelectedElement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayCondition.ExecuteCondition
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayConditionContext& ContextData                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayCondition::ExecuteCondition(const struct FGameplayConditionContext& ContextData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayCondition", "ExecuteCondition");

	Params::PhxGameplayCondition_ExecuteCondition Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayCondition.GetConditionSummaryStringBP
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxGameplayCondition::GetConditionSummaryStringBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayCondition", "GetConditionSummaryStringBP");

	Params::PhxGameplayCondition_GetConditionSummaryStringBP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayCondition.TestConditionBP
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const struct FGameplayConditionContext& ContextData                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayCondition::TestConditionBP(const struct FGameplayConditionContext& ContextData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayCondition", "TestConditionBP");

	Params::PhxGameplayCondition_TestConditionBP Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAutoAim.HandleGamePaused
// (Final, Native, Protected)
// Parameters:
// bool                                    bPaused                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAutoAim::HandleGamePaused(bool bPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoAim", "HandleGamePaused");

	Params::PhxAutoAim_HandleGamePaused Parms{};

	Parms.bPaused = bPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutoAim.OnRangedWeaponFired
// (Final, Native, Public)
// Parameters:
// class APhxPlayerCharacter*              Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxGunWeapon*                    Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAutoAim::OnRangedWeaponFired(class APhxPlayerCharacter* Player, class APhxGunWeapon* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoAim", "OnRangedWeaponFired");

	Params::PhxAutoAim_OnRangedWeaponFired Parms{};

	Parms.Player = Player;
	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraModifier.CombinePostProcessMaterials
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPostProcessSettings&      A                                                      (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FPostProcessSettings&      B                                                      (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   WeightScale                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPostProcessSettings             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FPostProcessSettings UPhxCameraModifier::CombinePostProcessMaterials(const struct FPostProcessSettings& A, const struct FPostProcessSettings& B, float WeightScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCameraModifier", "CombinePostProcessMaterials");

	Params::PhxCameraModifier_CombinePostProcessMaterials Parms{};

	Parms.A = std::move(A);
	Parms.B = std::move(B);
	Parms.WeightScale = WeightScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraModifier.Kill
// (Final, Native, Public, BlueprintCallable)

void UPhxCameraModifier::Kill()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "Kill");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraModifier.ModifierBegin
// (Native, Event, Public, BlueprintEvent)

void UPhxCameraModifier::ModifierBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "ModifierBegin");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraModifier.ModifierEnd
// (Native, Event, Public, BlueprintEvent)

void UPhxCameraModifier::ModifierEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "ModifierEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraModifier.Revive
// (Final, Native, Public, BlueprintCallable)

void UPhxCameraModifier::Revive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "Revive");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraModifier.GetAge
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  Seconds                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Frames                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCameraModifier::GetAge(float* Seconds, int32* Frames) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "GetAge");

	Params::PhxCameraModifier_GetAge Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxCameraModifier.GetAlpha
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCameraModifier::GetAlpha() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "GetAlpha");

	Params::PhxCameraModifier_GetAlpha Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraModifier.GetOwningRig
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCameraRig*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCameraRig* UPhxCameraModifier::GetOwningRig() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "GetOwningRig");

	Params::PhxCameraModifier_GetOwningRig Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraModifier.IsAlive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCameraModifier::IsAlive() const
{
	static class UFunction* Func = nullptr;

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

	Params::PhxCameraModifier_IsAlive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraModifier.IsDead
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

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

	Params::PhxCameraModifier_IsDead Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraModifier.IsDying
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCameraModifier::IsDying() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifier", "IsDying");

	Params::PhxCameraModifier_IsDying Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterCameraModifier.GetCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCharacter* UPhxCharacterCameraModifier::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterCameraModifier", "GetCharacter");

	Params::PhxCharacterCameraModifier_GetCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterCameraModifier.GetRig
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCameraRig*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCameraRig* UPhxCharacterCameraModifier::GetRig() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterCameraModifier", "GetRig");

	Params::PhxCharacterCameraModifier_GetRig Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HealthBlurCameraModifier.SetTargetWeight
// (Final, Native, Public)
// Parameters:
// float                                   NewTarget                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHealthBlurCameraModifier::SetTargetWeight(float NewTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthBlurCameraModifier", "SetTargetWeight");

	Params::HealthBlurCameraModifier_SetTargetWeight Parms{};

	Parms.NewTarget = NewTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_WaitForDamageEvent.OnActorRecievedDamage
// (Final, Native, Private)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_WaitForDamageEvent::OnActorRecievedDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_WaitForDamageEvent", "OnActorRecievedDamage");

	Params::PhxAbilityTask_WaitForDamageEvent_OnActorRecievedDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInputDebugger.OnInputKey
// (Final, Native, Protected)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputEvent                       EventType                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             AmountDepressed                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxInputDebugger::OnInputKey(const struct FKey& Key, const EInputEvent EventType, const float AmountDepressed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputDebugger", "OnInputKey");

	Params::PhxInputDebugger_OnInputKey Parms{};

	Parms.Key = std::move(Key);
	Parms.EventType = EventType;
	Parms.AmountDepressed = AmountDepressed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HighContrastComponent.ApplyHighContrast
// (Final, Native, Protected)
// Parameters:
// bool                                    bInHighContrastEnabled                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHighContrastComponent::ApplyHighContrast(bool bInHighContrastEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HighContrastComponent", "ApplyHighContrast");

	Params::HighContrastComponent_ApplyHighContrast Parms{};

	Parms.bInHighContrastEnabled = bInHighContrastEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HighContrastComponent.ApplySnowDeform
// (Final, Native, Protected)
// Parameters:
// bool                                    bInSnowDeformEnabled                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHighContrastComponent::ApplySnowDeform(bool bInSnowDeformEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HighContrastComponent", "ApplySnowDeform");

	Params::HighContrastComponent_ApplySnowDeform Parms{};

	Parms.bInSnowDeformEnabled = bInSnowDeformEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HighContrastComponent.SetPostProcessMaterialColors
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// const struct FLinearColor&              AllyColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              EnemyColor                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              PickupColor                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              HazardColor                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHighContrastComponent::SetPostProcessMaterialColors(const struct FLinearColor& AllyColor, const struct FLinearColor& EnemyColor, const struct FLinearColor& PickupColor, const struct FLinearColor& HazardColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HighContrastComponent", "SetPostProcessMaterialColors");

	Params::HighContrastComponent_SetPostProcessMaterialColors Parms{};

	Parms.AllyColor = std::move(AllyColor);
	Parms.EnemyColor = std::move(EnemyColor);
	Parms.PickupColor = std::move(PickupColor);
	Parms.HazardColor = std::move(HazardColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HighContrastComponent.SetStencilAndApply
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EHighContrastStencil                    InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHighContrastComponent::SetStencilAndApply(EHighContrastStencil InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HighContrastComponent", "SetStencilAndApply");

	Params::HighContrastComponent_SetStencilAndApply Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HighContrastComponent.SetStencilValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EHighContrastStencil                    InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHighContrastComponent::SetStencilValue(EHighContrastStencil InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HighContrastComponent", "SetStencilValue");

	Params::HighContrastComponent_SetStencilValue Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterAnimInstanceBase.OnTakePointDamage
// (Final, Native, Protected, HasDefaults)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              FHitComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ShotFromDirection                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterAnimInstanceBase::OnTakePointDamage(class AActor* DamagedActor, float Damage, class AController* InstigatedBy, const struct FVector& HitLocation, class UPrimitiveComponent* FHitComponent, class FName BoneName, const struct FVector& ShotFromDirection, const class UDamageType* DamageType, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterAnimInstanceBase", "OnTakePointDamage");

	Params::PhxCharacterAnimInstanceBase_OnTakePointDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.InstigatedBy = InstigatedBy;
	Parms.HitLocation = std::move(HitLocation);
	Parms.FHitComponent = FHitComponent;
	Parms.BoneName = BoneName;
	Parms.ShotFromDirection = std::move(ShotFromDirection);
	Parms.DamageType = DamageType;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GRPChargeComponent.AddCharge
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGRPChargeComponent::AddCharge(float Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPChargeComponent", "AddCharge");

	Params::GRPChargeComponent_AddCharge Parms{};

	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GRPChargeComponent.RefillCharge
// (Final, Native, Public, BlueprintCallable)

void UGRPChargeComponent::RefillCharge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPChargeComponent", "RefillCharge");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GRPChargeComponent.GetCharge
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UGRPChargeComponent::GetCharge() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPChargeComponent", "GetCharge");

	Params::GRPChargeComponent_GetCharge Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GRPChargeComponent.GetMaxCharge
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UGRPChargeComponent::GetMaxCharge() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPChargeComponent", "GetMaxCharge");

	Params::GRPChargeComponent_GetMaxCharge Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAutoBotPlayerLeash.FindActiveLeash
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    InWorldObject                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAutoBotPlayerLeash*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAutoBotPlayerLeash* APhxAutoBotPlayerLeash::FindActiveLeash(const class UObject* InWorldObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAutoBotPlayerLeash", "FindActiveLeash");

	Params::PhxAutoBotPlayerLeash_FindActiveLeash Parms{};

	Parms.InWorldObject = InWorldObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAutoBotPlayerLeash.FindNextActiveLeash
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    InWorldObject                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAutoBotPlayerLeash*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAutoBotPlayerLeash* APhxAutoBotPlayerLeash::FindNextActiveLeash(const class UObject* InWorldObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAutoBotPlayerLeash", "FindNextActiveLeash");

	Params::PhxAutoBotPlayerLeash_FindNextActiveLeash Parms{};

	Parms.InWorldObject = InWorldObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAutoBotPlayerLeash.Activate
// (Native, Public, BlueprintCallable)

void APhxAutoBotPlayerLeash::Activate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "Activate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutoBotPlayerLeash.Deactivate
// (Native, Public, BlueprintCallable)

void APhxAutoBotPlayerLeash::Deactivate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "Deactivate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutoBotPlayerLeash.PauseUpdate
// (Native, Public, BlueprintCallable)

void APhxAutoBotPlayerLeash::PauseUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "PauseUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutoBotPlayerLeash.ResumeUpdate
// (Native, Public, BlueprintCallable)

void APhxAutoBotPlayerLeash::ResumeUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "ResumeUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutoBotPlayerLeash.CanLeashActivate
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxAutoBotPlayerLeash::CanLeashActivate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "CanLeashActivate");

	Params::PhxAutoBotPlayerLeash_CanLeashActivate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAutoBotPlayerLeash.GetDesiredLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxAutoBotPlayerLeash::GetDesiredLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "GetDesiredLocation");

	Params::PhxAutoBotPlayerLeash_GetDesiredLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAutoBotPlayerLeash.InitSplineToPatrol
// (Final, Native, Public, BlueprintCallable, Const)

void APhxAutoBotPlayerLeash::InitSplineToPatrol() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "InitSplineToPatrol");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutoBotPlayerLeash.IsLeashActive
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxAutoBotPlayerLeash::IsLeashActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAutoBotPlayerLeash", "IsLeashActive");

	Params::PhxAutoBotPlayerLeash_IsLeashActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISensor_Touch.HandleActorHit
// (Final, Native, Private, HasOutParams, HasDefaults)
// Parameters:
// class AActor*                           SelfActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxAISensor_Touch::HandleActorHit(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISensor_Touch", "HandleActorHit");

	Params::PhxAISensor_Touch_HandleActorHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EnvironmentalHazard_Gore.OnBodyPartDetectionTimerExpired
// (Final, Native, Protected)

void AEnvironmentalHazard_Gore::OnBodyPartDetectionTimerExpired()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvironmentalHazard_Gore", "OnBodyPartDetectionTimerExpired");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraMover.Tick
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPhxCameraProperties&      DesiredProperties                                      (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCameraMover::Tick(const struct FPhxCameraProperties& DesiredProperties, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraMover", "Tick");

	Params::PhxCameraMover_Tick Parms{};

	Parms.DesiredProperties = std::move(DesiredProperties);
	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraMover.GetDesiredLocation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPhxCameraMover::GetDesiredLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraMover", "GetDesiredLocation");

	Params::PhxCameraMover_GetDesiredLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraMover.GetResolvedCameraTransform
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UPhxCameraMover::GetResolvedCameraTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraMover", "GetResolvedCameraTransform");

	Params::PhxCameraMover_GetResolvedCameraTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraMoverSpherecast.HasIgnoreTag
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UActorComponent*            Component                                              (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCameraMoverSpherecast::HasIgnoreTag(const class UActorComponent* Component) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraMoverSpherecast", "HasIgnoreTag");

	Params::PhxCameraMoverSpherecast_HasIgnoreTag Parms{};

	Parms.Component = Component;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Consumable.CanStartConsuming
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class APhxCharacter*                    ConsumedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AConsumable::CanStartConsuming(class APhxCharacter* ConsumedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Consumable", "CanStartConsuming");

	Params::Consumable_CanStartConsuming Parms{};

	Parms.ConsumedBy = ConsumedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Consumable.OnCharacterConsumeAnimationFinished
// (Event, Public, BlueprintEvent)

void AConsumable::OnCharacterConsumeAnimationFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Consumable", "OnCharacterConsumeAnimationFinished");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.Consumable.OnConsumed
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    ConsumedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AConsumable::OnConsumed(class APhxCharacter* ConsumedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Consumable", "OnConsumed");

	Params::Consumable_OnConsumed Parms{};

	Parms.ConsumedBy = ConsumedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Consumable.PlayConsumableMontage
// (Final, Native, Public)

void AConsumable::PlayConsumableMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Consumable", "PlayConsumableMontage");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Consumable.StopUsingConsumable
// (Native, Public)
// Parameters:
// class APhxCharacter*                    ConsumedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AConsumable::StopUsingConsumable(class APhxCharacter* ConsumedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Consumable", "StopUsingConsumable");

	Params::Consumable_StopUsingConsumable Parms{};

	Parms.ConsumedBy = ConsumedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Consumable.UseConsumable
// (Native, Public)
// Parameters:
// class APhxCharacter*                    ConsumedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AConsumable::UseConsumable(class APhxCharacter* ConsumedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Consumable", "UseConsumable");

	Params::Consumable_UseConsumable Parms{};

	Parms.ConsumedBy = ConsumedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HealthPack.GetHealAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AHealthPack::GetHealAmount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthPack", "GetHealAmount");

	Params::HealthPack_GetHealAmount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.BlockInteraction
// (Final, Native, Public, BlueprintCallable)

void UInteractableComponent::BlockInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "BlockInteraction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.DisableInteraction
// (Final, Native, Public, BlueprintCallable)

void UInteractableComponent::DisableInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "DisableInteraction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.EnableInteraction
// (Final, Native, Public, BlueprintCallable)

void UInteractableComponent::EnableInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "EnableInteraction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.HideUI
// (Final, Native, Public, BlueprintCallable)

void UInteractableComponent::HideUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "HideUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetCameraAngleRequired
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   Angle                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetCameraAngleRequired(float Angle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetCameraAngleRequired");

	Params::InteractableComponent_SetCameraAngleRequired Parms{};

	Parms.Angle = Angle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetEnableInteraction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetEnableInteraction(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetEnableInteraction");

	Params::InteractableComponent_SetEnableInteraction Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetFocusableRadius
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetFocusableRadius(float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetFocusableRadius");

	Params::InteractableComponent_SetFocusableRadius Parms{};

	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetMoveToSyncPointBeforeInteract
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bMoveToSyncPoint                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetMoveToSyncPointBeforeInteract(bool bMoveToSyncPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetMoveToSyncPointBeforeInteract");

	Params::InteractableComponent_SetMoveToSyncPointBeforeInteract Parms{};

	Parms.bMoveToSyncPoint = bMoveToSyncPoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetNearbyRadius
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetNearbyRadius(float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetNearbyRadius");

	Params::InteractableComponent_SetNearbyRadius Parms{};

	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetPlayerAngleRequired
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   Angle                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetPlayerAngleRequired(float Angle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetPlayerAngleRequired");

	Params::InteractableComponent_SetPlayerAngleRequired Parms{};

	Parms.Angle = Angle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetRelativeIconOffset
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   NewOffset                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetRelativeIconOffset(const struct FVector& NewOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetRelativeIconOffset");

	Params::InteractableComponent_SetRelativeIconOffset Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetSyncPointTransform
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                WorldSpaceTransform                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UInteractableComponent::SetSyncPointTransform(const struct FTransform& WorldSpaceTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetSyncPointTransform");

	Params::InteractableComponent_SetSyncPointTransform Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.SetZIconOffset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewZOffset                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableComponent::SetZIconOffset(float NewZOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "SetZIconOffset");

	Params::InteractableComponent_SetZIconOffset Parms{};

	Parms.NewZOffset = NewZOffset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.ShowUI
// (Final, Native, Public, BlueprintCallable)

void UInteractableComponent::ShowUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "ShowUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.UnblockInteraction
// (Final, Native, Public, BlueprintCallable)

void UInteractableComponent::UnblockInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "UnblockInteraction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractableComponent.BlueprintCanAutoExecute
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::BlueprintCanAutoExecute(const class APhxCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "BlueprintCanAutoExecute");

	Params::InteractableComponent_BlueprintCanAutoExecute Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.ButtonCanExecute
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::ButtonCanExecute(const class APhxCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "ButtonCanExecute");

	Params::InteractableComponent_ButtonCanExecute Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.CanAutoExecute
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::CanAutoExecute(const class APhxCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "CanAutoExecute");

	Params::InteractableComponent_CanAutoExecute Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetCameraAngleRequired
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetCameraAngleRequired() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetCameraAngleRequired");

	Params::InteractableComponent_GetCameraAngleRequired Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetCameraAngleRequiredCosine
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetCameraAngleRequiredCosine() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetCameraAngleRequiredCosine");

	Params::InteractableComponent_GetCameraAngleRequiredCosine Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetFocusableQuadrance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetFocusableQuadrance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetFocusableQuadrance");

	Params::InteractableComponent_GetFocusableQuadrance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetFocusableRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetFocusableRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetFocusableRadius");

	Params::InteractableComponent_GetFocusableRadius Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetInteractableButton
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInteractionButton                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInteractionButton UInteractableComponent::GetInteractableButton() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetInteractableButton");

	Params::InteractableComponent_GetInteractableButton Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetInteractionMontage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UInteractableComponent::GetInteractionMontage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetInteractionMontage");

	Params::InteractableComponent_GetInteractionMontage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetInteractionWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWSInteractionWidget*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSInteractionWidget* UInteractableComponent::GetInteractionWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetInteractionWidget");

	Params::InteractableComponent_GetInteractionWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetNearbyQuadrance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetNearbyQuadrance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetNearbyQuadrance");

	Params::InteractableComponent_GetNearbyQuadrance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetNearbyRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetNearbyRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetNearbyRadius");

	Params::InteractableComponent_GetNearbyRadius Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetPlayerAngleRequired
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetPlayerAngleRequired() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetPlayerAngleRequired");

	Params::InteractableComponent_GetPlayerAngleRequired Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetPlayerAngleRequiredCosine
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetPlayerAngleRequiredCosine() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetPlayerAngleRequiredCosine");

	Params::InteractableComponent_GetPlayerAngleRequiredCosine Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetPlayerFacingAngleRequiredCosine
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UInteractableComponent::GetPlayerFacingAngleRequiredCosine() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetPlayerFacingAngleRequiredCosine");

	Params::InteractableComponent_GetPlayerFacingAngleRequiredCosine Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetProximityToPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInteractableProximity                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInteractableProximity UInteractableComponent::GetProximityToPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetProximityToPlayer");

	Params::InteractableComponent_GetProximityToPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.GetValidInteractions
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<TSubclassOf<class UInteraction>> ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, UObjectWrapper, NativeAccessSpecifierPublic)

TArray<TSubclassOf<class UInteraction>> UInteractableComponent::GetValidInteractions() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "GetValidInteractions");

	Params::InteractableComponent_GetValidInteractions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.HasAnyValidInteraction
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::HasAnyValidInteraction(class APhxCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "HasAnyValidInteraction");

	Params::InteractableComponent_HasAnyValidInteraction Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.InteractionBlocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::InteractionBlocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "InteractionBlocked");

	Params::InteractableComponent_InteractionBlocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.InteractionEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::InteractionEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "InteractionEnabled");

	Params::InteractableComponent_InteractionEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.IntersectValidInteractions
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<TSubclassOf<class UInteraction>>&AvailableInteractions                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
// TArray<TSubclassOf<class UInteraction>>*Result                                                 (Parm, OutParm, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInteractableComponent::IntersectValidInteractions(const TArray<TSubclassOf<class UInteraction>>& AvailableInteractions, TArray<TSubclassOf<class UInteraction>>* Result) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "IntersectValidInteractions");

	Params::InteractableComponent_IntersectValidInteractions Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.IsInteractionClassValid
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UInteraction>         InteractionClass                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::IsInteractionClassValid(TSubclassOf<class UInteraction> InteractionClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "IsInteractionClassValid");

	Params::InteractableComponent_IsInteractionClassValid Parms{};

	Parms.InteractionClass = InteractionClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractableComponent.IsInteractionValid
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInteraction*                     Interaction                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractableComponent::IsInteractionValid(class UInteraction* Interaction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableComponent", "IsInteractionValid");

	Params::InteractableComponent_IsInteractionValid Parms{};

	Parms.Interaction = Interaction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnAlignmentComplete
// (Final, Native, Private)

void UPhxAIGameplayAbility_PairedAnimation::OnAlignmentComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnAlignmentComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnGrappleStateEntered
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     InAttackState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_PairedAnimation::OnGrappleStateEntered(class APhxCharacter* InCharacter, class UAttackState* InAttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnGrappleStateEntered");

	Params::PhxAIGameplayAbility_PairedAnimation_OnGrappleStateEntered Parms{};

	Parms.InCharacter = InCharacter;
	Parms.InAttackState = InAttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnGrappleStateExited
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     InAttackState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_PairedAnimation::OnGrappleStateExited(class APhxCharacter* InCharacter, class UAttackState* InAttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnGrappleStateExited");

	Params::PhxAIGameplayAbility_PairedAnimation_OnGrappleStateExited Parms{};

	Parms.InCharacter = InCharacter;
	Parms.InAttackState = InAttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnMontageBlendOut
// (Final, Native, Private)

void UPhxAIGameplayAbility_PairedAnimation::OnMontageBlendOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnMontageBlendOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnPairedAnimationCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_PairedAnimation::OnPairedAnimationCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnPairedAnimationCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnTargetEarlyExit
// (Final, Native, Private)

void UPhxAIGameplayAbility_PairedAnimation::OnTargetEarlyExit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnTargetEarlyExit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnTargetEnteredGrapplePuppetState
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    TargetCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrappledPuppetState*             TargetGrappledPuppetState                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_PairedAnimation::OnTargetEnteredGrapplePuppetState(class APhxCharacter* TargetCharacter, class UGrappledPuppetState* TargetGrappledPuppetState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnTargetEnteredGrapplePuppetState");

	Params::PhxAIGameplayAbility_PairedAnimation_OnTargetEnteredGrapplePuppetState Parms{};

	Parms.TargetCharacter = TargetCharacter;
	Parms.TargetGrappledPuppetState = TargetGrappledPuppetState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PairedAnimation.OnTargetFailToBeGrappled
// (Final, Native, Private)

void UPhxAIGameplayAbility_PairedAnimation::OnTargetFailToBeGrappled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PairedAnimation", "OnTargetFailToBeGrappled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.AllowLimboDamage
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::AllowLimboDamage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "AllowLimboDamage");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.AllowResurrect
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::AllowResurrect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "AllowResurrect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.AttemptResurrect
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::AttemptResurrect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "AttemptResurrect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.OnDeath
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::OnDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "OnDeath");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.OnGetupMontageFinished
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::OnGetupMontageFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "OnGetupMontageFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.OnLimboCharacterStateBegin
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::OnLimboCharacterStateBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "OnLimboCharacterStateBegin");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.OnLimboCharacterStateEnd
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::OnLimboCharacterStateEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "OnLimboCharacterStateEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Limbo.OnWaitRagdollSnapshotFinished
// (Final, Native, Private)

void UPhxAIGameplayAbility_Limbo::OnWaitRagdollSnapshotFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Limbo", "OnWaitRagdollSnapshotFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCraftingRecipe.GetIngredients
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TMap<TSubclassOf<class AItem>, int32>ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TMap<TSubclassOf<class AItem>, int32> UPhxCraftingRecipe::GetIngredients() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCraftingRecipe", "GetIngredients");

	Params::PhxCraftingRecipe_GetIngredients Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCraftingRecipe.GetName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FText                       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const class FText UPhxCraftingRecipe::GetName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCraftingRecipe", "GetName");

	Params::PhxCraftingRecipe_GetName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCraftingRecipe.GetRecipeTags
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTagContainer      ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FGameplayTagContainer UPhxCraftingRecipe::GetRecipeTags() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCraftingRecipe", "GetRecipeTags");

	Params::PhxCraftingRecipe_GetRecipeTags Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCraftingRecipe.GetUIModificationStats
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FPhxUIModStat>      ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FPhxUIModStat> UPhxCraftingRecipe::GetUIModificationStats() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCraftingRecipe", "GetUIModificationStats");

	Params::PhxCraftingRecipe_GetUIModificationStats Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCraftingRecipe.GetUIModStatValue
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FText&                      InStatName                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCraftingRecipe::GetUIModStatValue(const class FText& InStatName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCraftingRecipe", "GetUIModStatValue");

	Params::PhxCraftingRecipe_GetUIModStatValue Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCraftingRecipe.GetVID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UVirtualItemData*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UVirtualItemData* UPhxCraftingRecipe::GetVID() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCraftingRecipe", "GetVID");

	Params::PhxCraftingRecipe_GetVID Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWeaponModificationRecipe.GetAttachmentSocket
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class FName                       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class FName UPhxWeaponModificationRecipe::GetAttachmentSocket() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponModificationRecipe", "GetAttachmentSocket");

	Params::PhxWeaponModificationRecipe_GetAttachmentSocket Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWeaponModificationRecipe.GetWeaponModifications
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class UPhxWeaponModification*>ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

const TArray<class UPhxWeaponModification*> UPhxWeaponModificationRecipe::GetWeaponModifications() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponModificationRecipe", "GetWeaponModifications");

	Params::PhxWeaponModificationRecipe_GetWeaponModifications Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameplayAbility_Crawl.OnCrawlSpawn
// (Final, Native, Protected)

void UPhxAIGameplayAbility_Crawl::OnCrawlSpawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Crawl", "OnCrawlSpawn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Crawl.OnLegRemoved
// (Final, Native, Protected)

void UPhxAIGameplayAbility_Crawl::OnLegRemoved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Crawl", "OnLegRemoved");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDefaultMotionController.OnCharacterNotifyReceived
// (Final, Native, Private)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDefaultMotionController::OnCharacterNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDefaultMotionController", "OnCharacterNotifyReceived");

	Params::PhxDefaultMotionController_OnCharacterNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.KeypadKey.GetValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKeypadKey::GetValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeypadKey", "GetValue");

	Params::KeypadKey_GetValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxFlashlightModifier.IsDisabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxFlashlightModifier::IsDisabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightModifier", "IsDisabled");

	Params::PhxFlashlightModifier_IsDisabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryPanel.GetSlotRowAndColumn
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const class UInventorySlot*             InSlot                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutRow                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutCol                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryPanel::GetSlotRowAndColumn(const class UInventorySlot* InSlot, int32* OutRow, int32* OutCol)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryPanel", "GetSlotRowAndColumn");

	Params::InventoryPanel_GetSlotRowAndColumn Parms{};

	Parms.InSlot = InSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.InventoryPanel.GetAdjacentSlot
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const class UInventorySlot*             InSlot                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInventorySlot*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventorySlot* UInventoryPanel::GetAdjacentSlot(const class UInventorySlot* InSlot, EInputDirection Direction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryPanel", "GetAdjacentSlot");

	Params::InventoryPanel_GetAdjacentSlot Parms{};

	Parms.InSlot = InSlot;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryPanel.GetSelectedSlot
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UInventorySlot*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventorySlot* UInventoryPanel::GetSelectedSlot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryPanel", "GetSelectedSlot");

	Params::InventoryPanel_GetSelectedSlot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryBiosPanel.HandleAudioLogPlayed
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UDialogue*                        Dialogue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleAudioLogPlayed(class UDialogue* Dialogue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleAudioLogPlayed");

	Params::InventoryBiosPanel_HandleAudioLogPlayed Parms{};

	Parms.Dialogue = Dialogue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.HandleBioDetailsFocus
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsFocused                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleBioDetailsFocus(bool bIsFocused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleBioDetailsFocus");

	Params::InventoryBiosPanel_HandleBioDetailsFocus Parms{};

	Parms.bIsFocused = bIsFocused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.HandleBioDetailsNavigation
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UPhxSelectable*                   Selectable                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleBioDetailsNavigation(class UPhxSelectable* Selectable, EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleBioDetailsNavigation");

	Params::InventoryBiosPanel_HandleBioDetailsNavigation Parms{};

	Parms.Selectable = Selectable;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.HandleBioSelection
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UPhxSelectable*                   InSlot                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleBioSelection(class UPhxSelectable* InSlot, EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleBioSelection");

	Params::InventoryBiosPanel_HandleBioSelection Parms{};

	Parms.InSlot = InSlot;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.HandleIntelDetailsFocus
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsFocused                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleIntelDetailsFocus(bool bIsFocused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleIntelDetailsFocus");

	Params::InventoryBiosPanel_HandleIntelDetailsFocus Parms{};

	Parms.bIsFocused = bIsFocused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.HandleKeyCodeHintViewed
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsViewing                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleKeyCodeHintViewed(bool bIsViewing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleKeyCodeHintViewed");

	Params::InventoryBiosPanel_HandleKeyCodeHintViewed Parms{};

	Parms.bIsViewing = bIsViewing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.HandleLevelSelection
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleLevelSelection(int32 Index_0, EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleLevelSelection");

	Params::InventoryBiosPanel_HandleLevelSelection Parms{};

	Parms.Index_0 = Index_0;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.HandleNavigationContainerChange
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UPanelWidget*                     Container                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryBiosPanel::HandleNavigationContainerChange(class UPanelWidget* Container, EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "HandleNavigationContainerChange");

	Params::InventoryBiosPanel_HandleNavigationContainerChange Parms{};

	Parms.Container = Container;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryBiosPanel.OnAudioLogEnded
// (Final, Native, Protected)

void UInventoryBiosPanel::OnAudioLogEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBiosPanel", "OnAudioLogEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent.HandleAIDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawnerComponent::HandleAIDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent", "HandleAIDestroyed");

	Params::PhxAISpawnerComponent_HandleAIDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent.HandleAIDied
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawnerComponent::HandleAIDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent", "HandleAIDied");

	Params::PhxAISpawnerComponent_HandleAIDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent.GetLastSpawnedAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxAICharacter*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacter* UPhxAISpawnerComponent::GetLastSpawnedAI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent", "GetLastSpawnedAI");

	Params::PhxAISpawnerComponent_GetLastSpawnedAI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryEquipmentGridWidget.GetWidgetSwitcher
// (Final, Native, Public)
// Parameters:
// class UWidgetSwitcher*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWidgetSwitcher* UInventoryEquipmentGridWidget::GetWidgetSwitcher()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryEquipmentGridWidget", "GetWidgetSwitcher");

	Params::InventoryEquipmentGridWidget_GetWidgetSwitcher Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryEquipmentGridWidget.OnConstruct
// (Final, Native, Protected, BlueprintCallable)

void UInventoryEquipmentGridWidget::OnConstruct()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryEquipmentGridWidget", "OnConstruct");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterContextualAnimComponent.AddLightWeightContextualAnimTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EHeadTrackingPriorityCategory           PriorityCategory                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PriorityValue                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    CheckLOS                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterContextualAnimComponent::AddLightWeightContextualAnimTarget(class AActor* TargetActor, EHeadTrackingPriorityCategory PriorityCategory, int32 PriorityValue, bool CheckLOS)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterContextualAnimComponent", "AddLightWeightContextualAnimTarget");

	Params::CharacterContextualAnimComponent_AddLightWeightContextualAnimTarget Parms{};

	Parms.TargetActor = TargetActor;
	Parms.PriorityCategory = PriorityCategory;
	Parms.PriorityValue = PriorityValue;
	Parms.CheckLOS = CheckLOS;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterContextualAnimComponent.OnCharacterDeathEvent
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterContextualAnimComponent::OnCharacterDeathEvent(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterContextualAnimComponent", "OnCharacterDeathEvent");

	Params::CharacterContextualAnimComponent_OnCharacterDeathEvent Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterContextualAnimComponent.RemoveLightWeightContextualAnimTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterContextualAnimComponent::RemoveLightWeightContextualAnimTarget(class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterContextualAnimComponent", "RemoveLightWeightContextualAnimTarget");

	Params::CharacterContextualAnimComponent_RemoveLightWeightContextualAnimTarget Parms{};

	Parms.TargetActor = TargetActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterContextualAnimComponent.StartFullBodyContextualAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSwitchState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUnarmedOnly                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterContextualAnimComponent::StartFullBodyContextualAnimation(class UAnimMontage* Montage, bool bSwitchState, bool bUnarmedOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterContextualAnimComponent", "StartFullBodyContextualAnimation");

	Params::CharacterContextualAnimComponent_StartFullBodyContextualAnimation Parms{};

	Parms.Montage = Montage;
	Parms.bSwitchState = bSwitchState;
	Parms.bUnarmedOnly = bUnarmedOnly;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CharacterContextualAnimComponent.UpdateCombatHeadTrackingTarget
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    Attacker                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     AttackState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterContextualAnimComponent::UpdateCombatHeadTrackingTarget(class APhxCharacter* Attacker, class UAttackState* AttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterContextualAnimComponent", "UpdateCombatHeadTrackingTarget");

	Params::CharacterContextualAnimComponent_UpdateCombatHeadTrackingTarget Parms{};

	Parms.Attacker = Attacker;
	Parms.AttackState = AttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveAIResourceAcquired
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UObject*                          Owner                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIResource_BlueprintBase::ReceiveAIResourceAcquired(class UObject* Owner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIResource_BlueprintBase", "ReceiveAIResourceAcquired");

	Params::PhxAIResource_BlueprintBase_ReceiveAIResourceAcquired Parms{};

	Parms.Owner = Owner;

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


// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveAIResourceReleased
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UObject*                          Owner                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIResource_BlueprintBase::ReceiveAIResourceReleased(class UObject* Owner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIResource_BlueprintBase", "ReceiveAIResourceReleased");

	Params::PhxAIResource_BlueprintBase_ReceiveAIResourceReleased Parms{};

	Parms.Owner = Owner;

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


// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveStartPlay
// (Event, Protected, BlueprintEvent)

void UPhxAIResource_BlueprintBase::ReceiveStartPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIResource_BlueprintBase", "ReceiveStartPlay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveStopPlay
// (Event, Protected, BlueprintEvent)

void UPhxAIResource_BlueprintBase::ReceiveStopPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIResource_BlueprintBase", "ReceiveStopPlay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveTick
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIResource_BlueprintBase::ReceiveTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIResource_BlueprintBase", "ReceiveTick");

	Params::PhxAIResource_BlueprintBase_ReceiveTick Parms{};

	Parms.DeltaTime = DeltaTime;

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


// Function Phoenix.PhxAIResource_BlueprintBase.ReceiveTryAcquireAIResource
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UObject*                          Requester                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIResource_BlueprintBase::ReceiveTryAcquireAIResource(class UObject* Requester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIResource_BlueprintBase", "ReceiveTryAcquireAIResource");

	Params::PhxAIResource_BlueprintBase_ReceiveTryAcquireAIResource Parms{};

	Parms.Requester = Requester;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSpline.DisableInteractableComponents
// (Final, Native, Public, BlueprintCallable)

void APhxSpline::DisableInteractableComponents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "DisableInteractableComponents");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSpline.EnableInteractableComponents
// (Final, Native, Public, BlueprintCallable)

void APhxSpline::EnableInteractableComponents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "EnableInteractableComponents");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSpline.GetDirectionAlongSpline
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Axis                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxSpline::GetDirectionAlongSpline(float Distance, const struct FVector& Axis) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "GetDirectionAlongSpline");

	Params::PhxSpline_GetDirectionAlongSpline Parms{};

	Parms.Distance = Distance;
	Parms.Axis = std::move(Axis);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSpline.GetEndpoints
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      Start                                                  (Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FTransform*                      End                                                    (Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void APhxSpline::GetEndpoints(struct FTransform* Start, struct FTransform* End) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "GetEndpoints");

	Params::PhxSpline_GetEndpoints Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxSpline.GetInteractableComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ESplineEnd                              End                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInteractableComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInteractableComponent* APhxSpline::GetInteractableComponent(ESplineEnd End) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "GetInteractableComponent");

	Params::PhxSpline_GetInteractableComponent Parms{};

	Parms.End = End;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSpline.GetNearesetEnd
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   WorldVector                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ESplineEnd                              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESplineEnd APhxSpline::GetNearesetEnd(const struct FVector& WorldVector) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "GetNearesetEnd");

	Params::PhxSpline_GetNearesetEnd Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSpline.GetPositionAlongSpline
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxSpline::GetPositionAlongSpline(float Distance) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "GetPositionAlongSpline");

	Params::PhxSpline_GetPositionAlongSpline Parms{};

	Parms.Distance = Distance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSpline.GetRotationAlongSpline
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator APhxSpline::GetRotationAlongSpline(float Distance) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "GetRotationAlongSpline");

	Params::PhxSpline_GetRotationAlongSpline Parms{};

	Parms.Distance = Distance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSpline.GetSplineLength
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxSpline::GetSplineLength() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSpline", "GetSplineLength");

	Params::PhxSpline_GetSplineLength Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDanglerTunnel.PlaySpawningParticleFX
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UNiagaraSystem*                   ParticleSystem                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDanglerTunnel::PlaySpawningParticleFX(class UNiagaraSystem* ParticleSystem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDanglerTunnel", "PlaySpawningParticleFX");

	Params::PhxDanglerTunnel_PlaySpawningParticleFX Parms{};

	Parms.ParticleSystem = ParticleSystem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDanglerTunnel.SpawnAttackDangler
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxAISpawnerComponent*           Spawner                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDanglerTunnel::SpawnAttackDangler(class UPhxAISpawnerComponent* Spawner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDanglerTunnel", "SpawnAttackDangler");

	Params::PhxDanglerTunnel_SpawnAttackDangler Parms{};

	Parms.Spawner = Spawner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDanglerTunnel.StartCrawlingParticleFX
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UNiagaraSystem*                   ParticleSystem                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDanglerTunnel::StartCrawlingParticleFX(class UNiagaraSystem* ParticleSystem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDanglerTunnel", "StartCrawlingParticleFX");

	Params::PhxDanglerTunnel_StartCrawlingParticleFX Parms{};

	Parms.ParticleSystem = ParticleSystem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDanglerTunnel.StopCrawlingParticleFX
// (Final, Native, Public, BlueprintCallable)

void APhxDanglerTunnel::StopCrawlingParticleFX()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDanglerTunnel", "StopCrawlingParticleFX");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDanglerTunnel.TestParticles
// (Final, Native, Public)

void APhxDanglerTunnel::TestParticles()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDanglerTunnel", "TestParticles");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDanglerTunnel.GetNormalizedLocationAndRotation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   NormalizedLocation                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        OutRotation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void APhxDanglerTunnel::GetNormalizedLocationAndRotation(float NormalizedLocation, struct FVector* OutLocation, struct FRotator* OutRotation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDanglerTunnel", "GetNormalizedLocationAndRotation");

	Params::PhxDanglerTunnel_GetNormalizedLocationAndRotation Parms{};

	Parms.NormalizedLocation = NormalizedLocation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxDanglerTunnel.IsPlayerFlashlightAimedAtDangler
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APhxAICharacter*            Dangler                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxDanglerTunnel::IsPlayerFlashlightAimedAtDangler(const class APhxAICharacter* Dangler) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDanglerTunnel", "IsPlayerFlashlightAimedAtDangler");

	Params::PhxDanglerTunnel_IsPlayerFlashlightAimedAtDangler Parms{};

	Parms.Dangler = Dangler;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetChargeLevel
// (Final, Native, Public, Const)
// Parameters:
// float                                   ChargeHoldTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UChargedGroundSlamComponent::GetChargeLevel(float ChargeHoldTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetChargeLevel");

	Params::ChargedGroundSlamComponent_GetChargeLevel Parms{};

	Parms.ChargeHoldTime = ChargeHoldTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamCrateDamageTypeClass
// (Final, Native, Public, Const)
// Parameters:
// TSubclassOf<class UDamageType>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UDamageType> UChargedGroundSlamComponent::GetGroundSlamCrateDamageTypeClass() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetGroundSlamCrateDamageTypeClass");

	Params::ChargedGroundSlamComponent_GetGroundSlamCrateDamageTypeClass Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamCratesDamage
// (Final, Native, Public, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChargedGroundSlamComponent::GetGroundSlamCratesDamage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetGroundSlamCratesDamage");

	Params::ChargedGroundSlamComponent_GetGroundSlamCratesDamage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamCratesDamageRange
// (Final, Native, Public, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChargedGroundSlamComponent::GetGroundSlamCratesDamageRange() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetGroundSlamCratesDamageRange");

	Params::ChargedGroundSlamComponent_GetGroundSlamCratesDamageRange Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamDamageMultiplier
// (Final, Native, Public, Const)
// Parameters:
// float                                   ChargeHoldTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChargedGroundSlamComponent::GetGroundSlamDamageMultiplier(float ChargeHoldTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetGroundSlamDamageMultiplier");

	Params::ChargedGroundSlamComponent_GetGroundSlamDamageMultiplier Parms{};

	Parms.ChargeHoldTime = ChargeHoldTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamDamageTypeClass
// (Final, Native, Public, Const)
// Parameters:
// float                                   ChargeHoldTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UDamageType>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UDamageType> UChargedGroundSlamComponent::GetGroundSlamDamageTypeClass(float ChargeHoldTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetGroundSlamDamageTypeClass");

	Params::ChargedGroundSlamComponent_GetGroundSlamDamageTypeClass Parms{};

	Parms.ChargeHoldTime = ChargeHoldTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamDebugDuration
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChargedGroundSlamComponent::GetGroundSlamDebugDuration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetGroundSlamDebugDuration");

	Params::ChargedGroundSlamComponent_GetGroundSlamDebugDuration Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ChargedGroundSlamComponent.GetGroundSlamRangeMultiplier
// (Final, Native, Public, Const)
// Parameters:
// float                                   ChargeHoldTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChargedGroundSlamComponent::GetGroundSlamRangeMultiplier(float ChargeHoldTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChargedGroundSlamComponent", "GetGroundSlamRangeMultiplier");

	Params::ChargedGroundSlamComponent_GetGroundSlamRangeMultiplier Parms{};

	Parms.ChargeHoldTime = ChargeHoldTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWeaponModification.ApplyChanges
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AWeapon*                          Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeaponModification::ApplyChanges(class AWeapon* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponModification", "ApplyChanges");

	Params::PhxWeaponModification_ApplyChanges Parms{};

	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeaponModification.OnEquip
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AWeapon*                          Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeaponModification::OnEquip(class AWeapon* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponModification", "OnEquip");

	Params::PhxWeaponModification_OnEquip Parms{};

	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeaponModification.OnUnequip
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AWeapon*                          Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeaponModification::OnUnequip(class AWeapon* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponModification", "OnUnequip");

	Params::PhxWeaponModification_OnUnequip Parms{};

	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeaponModification.UndoChanges
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AWeapon*                          Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeaponModification::UndoChanges(class AWeapon* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponModification", "UndoChanges");

	Params::PhxWeaponModification_UndoChanges Parms{};

	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeaponModification.GetAssetToLoad
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// class AWeapon*                          Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FSoftObjectPath                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FSoftObjectPath UPhxWeaponModification::GetAssetToLoad(class AWeapon* Weapon) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponModification", "GetAssetToLoad");

	Params::PhxWeaponModification_GetAssetToLoad Parms{};

	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMaterialWeaponMod.GetDynamicMaterialInstance
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AWeapon*                          Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstanceDynamic*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UPhxMaterialWeaponMod::GetDynamicMaterialInstance(class AWeapon* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMaterialWeaponMod", "GetDynamicMaterialInstance");

	Params::PhxMaterialWeaponMod_GetDynamicMaterialInstance Parms{};

	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Checkpoint.CheckpointReached
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxPlayerCharacter*              Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACheckpoint::CheckpointReached(class APhxPlayerCharacter* Player, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "CheckpointReached");

	Params::Checkpoint_CheckpointReached Parms{};

	Parms.Player = Player;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Checkpoint.DisableCheckpoint
// (Final, Native, Public, BlueprintCallable)

void ACheckpoint::DisableCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "DisableCheckpoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Checkpoint.EnableCheckpoint
// (Final, Native, Public, BlueprintCallable)

void ACheckpoint::EnableCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "EnableCheckpoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Checkpoint.NotifyCheckpointReady
// (Final, Native, Public, BlueprintCallable)

void ACheckpoint::NotifyCheckpointReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "NotifyCheckpointReady");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Checkpoint.OnBeginOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           MyActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACheckpoint::OnBeginOverlap(class AActor* MyActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "OnBeginOverlap");

	Params::Checkpoint_OnBeginOverlap Parms{};

	Parms.MyActor = MyActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Checkpoint.OnCompanionSpawned
// (Final, Native, Protected)
// Parameters:
// class APhxAICharacter*                  SpawnedAI                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAISpawnResultCode                   ResultCode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SpawnUid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACheckpoint::OnCompanionSpawned(class APhxAICharacter* SpawnedAI, EPhxAISpawnResultCode ResultCode, int32 SpawnUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "OnCompanionSpawned");

	Params::Checkpoint_OnCompanionSpawned Parms{};

	Parms.SpawnedAI = SpawnedAI;
	Parms.ResultCode = ResultCode;
	Parms.SpawnUid = SpawnUid;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Checkpoint.GetCheckpointId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class FName ACheckpoint::GetCheckpointId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "GetCheckpointId");

	Params::Checkpoint_GetCheckpointId Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Checkpoint.IsCheckpointEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ACheckpoint::IsCheckpointEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Checkpoint", "IsCheckpointEnabled");

	Params::Checkpoint_IsCheckpointEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.MotionMatchCostTest.CancelTest
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bWasCompleted                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMotionMatchCostTest::CancelTest(bool bWasCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostTest", "CancelTest");

	Params::MotionMatchCostTest_CancelTest Parms{};

	Parms.bWasCompleted = bWasCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MotionMatchCostTest.CollectCost
// (Final, Native, Public)
// Parameters:
// float                                   AvgCost                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMotionMatchCostTest::CollectCost(float AvgCost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostTest", "CollectCost");

	Params::MotionMatchCostTest_CollectCost Parms{};

	Parms.AvgCost = AvgCost;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MotionMatchCostTest.ExecuteTest
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EMotionMatchTestAI                      ChosenSubtestAI                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMotionMatchTestMotion                  ChosenSubtestMotion                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMotionMatchTestMovement                ChosenSubtestMovement                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMotionMatchCostTest::ExecuteTest(EMotionMatchTestAI ChosenSubtestAI, EMotionMatchTestMotion ChosenSubtestMotion, EMotionMatchTestMovement ChosenSubtestMovement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostTest", "ExecuteTest");

	Params::MotionMatchCostTest_ExecuteTest Parms{};

	Parms.ChosenSubtestAI = ChosenSubtestAI;
	Parms.ChosenSubtestMotion = ChosenSubtestMotion;
	Parms.ChosenSubtestMovement = ChosenSubtestMovement;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MotionMatchCostTest.SaveTestResults
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SaveDirectory                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    AllowOverWriting                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AMotionMatchCostTest::SaveTestResults(const class FString& SaveDirectory, const class FString& Filename, bool AllowOverWriting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostTest", "SaveTestResults");

	Params::MotionMatchCostTest_SaveTestResults Parms{};

	Parms.SaveDirectory = std::move(SaveDirectory);
	Parms.Filename = std::move(Filename);
	Parms.AllowOverWriting = AllowOverWriting;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.MotionMatchCostTest.SetCostRetriever
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMotionMatchCostRetriever*        Retriever                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMotionMatchCostTest::SetCostRetriever(class UMotionMatchCostRetriever* Retriever)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostTest", "SetCostRetriever");

	Params::MotionMatchCostTest_SetCostRetriever Parms{};

	Parms.Retriever = Retriever;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAmbienceManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAmbienceManager*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAmbienceManager* APhxAmbienceManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAmbienceManager", "Get");

	Params::PhxAmbienceManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAmbienceManager.EnterAmbientRegion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AAmbientRegion*                   AmbientRegion                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAmbienceManager::EnterAmbientRegion(class AAmbientRegion* AmbientRegion)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmbienceManager", "EnterAmbientRegion");

	Params::PhxAmbienceManager_EnterAmbientRegion Parms{};

	Parms.AmbientRegion = AmbientRegion;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAmbienceManager.ExitAmbientRegion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AAmbientRegion*                   AmbientRegion                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAmbienceManager::ExitAmbientRegion(class AAmbientRegion* AmbientRegion)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmbienceManager", "ExitAmbientRegion");

	Params::PhxAmbienceManager_ExitAmbientRegion Parms{};

	Parms.AmbientRegion = AmbientRegion;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAmbienceManager.VerifySorting
// (Final, Native, Public, BlueprintCallable)

void APhxAmbienceManager::VerifySorting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmbienceManager", "VerifySorting");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.CinematicState.OnEndFakeCinematic
// (Final, Native, Protected)

void UCinematicState::OnEndFakeCinematic()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CinematicState", "OnEndFakeCinematic");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryDetails.ApplyVID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UVirtualItemData*           InVID                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryDetails::ApplyVID(const class UVirtualItemData* InVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryDetails", "ApplyVID");

	Params::InventoryDetails_ApplyVID Parms{};

	Parms.InVID = InVID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryDetails.SetFocused
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bInFocused                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryDetails::SetFocused(bool bInFocused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryDetails", "SetFocused");

	Params::InventoryDetails_SetFocused Parms{};

	Parms.bInFocused = bInFocused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryDetails.SetItemDetails
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UInventoryDetails::SetItemDetails(const struct FItemData& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryDetails", "SetItemDetails");

	Params::InventoryDetails_SetItemDetails Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryDetails.IsFocused
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventoryDetails::IsFocused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryDetails", "IsFocused");

	Params::InventoryDetails_IsFocused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameplayAbility_Stumble.OnMontageEnded
// (Final, Native, Private)

void UPhxAIGameplayAbility_Stumble::OnMontageEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Stumble", "OnMontageEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawningSystem.DespawnAI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIDespawnReason                     Reason                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnemiesOnly                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawningSystem::DespawnAI(class UObject* WorldContextObject, EPhxAIDespawnReason Reason, bool bEnemiesOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAISpawningSystem", "DespawnAI");

	Params::PhxAISpawningSystem_DespawnAI Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Reason = Reason;
	Parms.bEnemiesOnly = bEnemiesOnly;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawningSystem.DespawnAICharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIDespawnReason                     Reason                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawningSystem::DespawnAICharacter(class UObject* WorldContextObject, class APhxAICharacter* Character, EPhxAIDespawnReason Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAISpawningSystem", "DespawnAICharacter");

	Params::PhxAISpawningSystem_DespawnAICharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Character = Character;
	Parms.Reason = Reason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.OptionsWidget.Close
// (Event, Public, BlueprintEvent)

void UOptionsWidget::Close()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OptionsWidget", "Close");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.OptionsWidget.Open
// (Event, Public, BlueprintEvent)

void UOptionsWidget::Open()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OptionsWidget", "Open");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.OptionsWidget.SetSelection
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   ButtonIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsRight                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPlayAnimation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOptionsWidget::SetSelection(int32 ButtonIndex, bool bIsRight, bool bPlayAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OptionsWidget", "SetSelection");

	Params::OptionsWidget_SetSelection Parms{};

	Parms.ButtonIndex = ButtonIndex;
	Parms.bIsRight = bIsRight;
	Parms.bPlayAnimation = bPlayAnimation;

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


// Function Phoenix.PhxAIPointOfInterest.DisableBroadcasting
// (Final, Native, Public, BlueprintCallable)

void APhxAIPointOfInterest::DisableBroadcasting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterest", "DisableBroadcasting");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIPointOfInterest.EnableBroadcasting
// (Final, Native, Public, BlueprintCallable)

void APhxAIPointOfInterest::EnableBroadcasting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterest", "EnableBroadcasting");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIPointOfInterest.GetBlackboardValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   idx                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlackboardValue_Base*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlackboardValue_Base* APhxAIPointOfInterest::GetBlackboardValue(int32 idx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterest", "GetBlackboardValue");

	Params::PhxAIPointOfInterest_GetBlackboardValue Parms{};

	Parms.idx = idx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIPointOfInterest.GetBlackboardValuesCount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxAIPointOfInterest::GetBlackboardValuesCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterest", "GetBlackboardValuesCount");

	Params::PhxAIPointOfInterest_GetBlackboardValuesCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIPointOfInterest.UpdateEditorPreview
// (Final, Native, Private)

void APhxAIPointOfInterest::UpdateEditorPreview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterest", "UpdateEditorPreview");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFSM.OnCharacterHealthModified
// (Final, Native, Protected)
// Parameters:
// class UPhxHealthComponent*              HealthComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFSM::OnCharacterHealthModified(class UPhxHealthComponent* HealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFSM", "OnCharacterHealthModified");

	Params::InventoryFSM_OnCharacterHealthModified Parms{};

	Parms.HealthComp = HealthComp;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixGameModeBase.DisableUI
// (Event, Public, BlueprintEvent)

void APhoenixGameModeBase::DisableUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixGameModeBase", "DisableUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhoenixGameModeBase.EnableUI
// (Event, Public, BlueprintEvent)

void APhoenixGameModeBase::EnableUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixGameModeBase", "EnableUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhoenixGameModeBase.OnSecondControllerAttached
// (Final, Native, Public)

void APhoenixGameModeBase::OnSecondControllerAttached()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixGameModeBase", "OnSecondControllerAttached");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixGameModeBase.GetDifficultySettings
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxDifficultyLevel                     InDifficulty                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxDifficultySettings*     ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UPhxDifficultySettings* APhoenixGameModeBase::GetDifficultySettings(EPhxDifficultyLevel InDifficulty) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixGameModeBase", "GetDifficultySettings");

	Params::PhoenixGameModeBase_GetDifficultySettings Parms{};

	Parms.InDifficulty = InDifficulty;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDifficultySettings.GetAmmoDropQuantityMultiplier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxDifficultySettings::GetAmmoDropQuantityMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDifficultySettings", "GetAmmoDropQuantityMultiplier");

	Params::PhxDifficultySettings_GetAmmoDropQuantityMultiplier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDifficultySettings.GetCreditsDropQuantityMultiplier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxDifficultySettings::GetCreditsDropQuantityMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDifficultySettings", "GetCreditsDropQuantityMultiplier");

	Params::PhxDifficultySettings_GetCreditsDropQuantityMultiplier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDifficultySettings.GetCustomAutoSaveToken
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxDifficultySettings::GetCustomAutoSaveToken() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDifficultySettings", "GetCustomAutoSaveToken");

	Params::PhxDifficultySettings_GetCustomAutoSaveToken Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDifficultySettings.GetGRPGrabCostMultiplier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxDifficultySettings::GetGRPGrabCostMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDifficultySettings", "GetGRPGrabCostMultiplier");

	Params::PhxDifficultySettings_GetGRPGrabCostMultiplier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDifficultySettings.GetGRPHoldCostMultiplier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxDifficultySettings::GetGRPHoldCostMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDifficultySettings", "GetGRPHoldCostMultiplier");

	Params::PhxDifficultySettings_GetGRPHoldCostMultiplier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDifficultySettings.GetHealAmountMultiplier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxDifficultySettings::GetHealAmountMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDifficultySettings", "GetHealAmountMultiplier");

	Params::PhxDifficultySettings_GetHealAmountMultiplier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDifficultySettings.GetTimeAfterVirusToMutateMultiplier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxDifficultySettings::GetTimeAfterVirusToMutateMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDifficultySettings", "GetTimeAfterVirusToMutateMultiplier");

	Params::PhxDifficultySettings_GetTimeAfterVirusToMutateMultiplier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryTab.SetSelected
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bSelected                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryTab::SetSelected(bool bSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryTab", "SetSelected");

	Params::InventoryTab_SetSelected Parms{};

	Parms.bSelected = bSelected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISenseComponent.EnableSensing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISenseComponent::EnableSensing(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISenseComponent", "EnableSensing");

	Params::PhxAISenseComponent_EnableSensing Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISenseComponent.HandleSourceDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISenseComponent::HandleSourceDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISenseComponent", "HandleSourceDestroyed");

	Params::PhxAISenseComponent_HandleSourceDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryOverlayWidget.GetEquipmentWidget
// (Final, Native, Public)
// Parameters:
// class UInventoryEquipmentGridWidget*    ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventoryEquipmentGridWidget* UInventoryOverlayWidget::GetEquipmentWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryOverlayWidget", "GetEquipmentWidget");

	Params::InventoryOverlayWidget_GetEquipmentWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryOverlayWidget.GetSalvageWidget
// (Final, Native, Public)
// Parameters:
// class UInventoryItemGridWidget*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventoryItemGridWidget* UInventoryOverlayWidget::GetSalvageWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryOverlayWidget", "GetSalvageWidget");

	Params::InventoryOverlayWidget_GetSalvageWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Item.GetMeshComp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UStaticMeshComponent* AItem::GetMeshComp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Item", "GetMeshComp");

	Params::Item_GetMeshComp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnAbortActionTagAdded
// (Final, Native, Private)

void UPhxGameplayAbility_Interaction::OnAbortActionTagAdded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnAbortActionTagAdded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnCharacterReachedSyncPoint
// (Native, Protected)

void UPhxGameplayAbility_Interaction::OnCharacterReachedSyncPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnCharacterReachedSyncPoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnMontageFinished
// (Native, Protected)

void UPhxGameplayAbility_Interaction::OnMontageFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnMontageFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnMontageInterrupted
// (Native, Protected)

void UPhxGameplayAbility_Interaction::OnMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnMovementModeRestoreDelayFinished
// (Native, Protected)

void UPhxGameplayAbility_Interaction::OnMovementModeRestoreDelayFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnMovementModeRestoreDelayFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnNotifyReceived
// (Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Interaction::OnNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnNotifyReceived");

	Params::PhxGameplayAbility_Interaction_OnNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnNotifyStateBegin
// (Native, Protected)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Interaction::OnNotifyStateBegin(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnNotifyStateBegin");

	Params::PhxGameplayAbility_Interaction_OnNotifyStateBegin Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnNotifyStateEnd
// (Native, Protected)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Interaction::OnNotifyStateEnd(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnNotifyStateEnd");

	Params::PhxGameplayAbility_Interaction_OnNotifyStateEnd Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnUnequipFinished
// (Native, Protected)

void UPhxGameplayAbility_Interaction::OnUnequipFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnUnequipFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Interaction.OnWaitForNotifyTimedOut
// (Native, Protected)

void UPhxGameplayAbility_Interaction::OnWaitForNotifyTimedOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Interaction", "OnWaitForNotifyTimedOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GadgetInteraction.OnCharacterHealthModified
// (Final, Native, Protected)
// Parameters:
// class UPhxHealthComponent*              HealthComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_GadgetInteraction::OnCharacterHealthModified(class UPhxHealthComponent* HealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GadgetInteraction", "OnCharacterHealthModified");

	Params::PhxGameplayAbility_GadgetInteraction_OnCharacterHealthModified Parms{};

	Parms.HealthComp = HealthComp;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GadgetInteraction.OnInteractableComponentEnabled
// (Final, Native, Protected)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_GadgetInteraction::OnInteractableComponentEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GadgetInteraction", "OnInteractableComponentEnabled");

	Params::PhxGameplayAbility_GadgetInteraction_OnInteractableComponentEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GadgetInteraction.OnInteractionFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_GadgetInteraction::OnInteractionFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GadgetInteraction", "OnInteractionFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.DevMenuState.OnPlayerInventoryChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// const class FName&                      Name_0                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDevMenuState::OnPlayerInventoryChanged(const class FName& Name_0, int32 Quantity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DevMenuState", "OnPlayerInventoryChanged");

	Params::DevMenuState_OnPlayerInventoryChanged Parms{};

	Parms.Name_0 = Name_0;
	Parms.Quantity = Quantity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_TwoHead_RipSides.OnRipMontageCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_TwoHead_RipSides::OnRipMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_TwoHead_RipSides", "OnRipMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.DoOnceTriggerBox.Reset
// (Final, Native, Public)

void ADoOnceTriggerBox::Reset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DoOnceTriggerBox", "Reset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.DoorUIWidget.OnOpenAnimationFinished
// (Final, Native, Protected)

void UDoorUIWidget::OnOpenAnimationFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DoorUIWidget", "OnOpenAnimationFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.DoorUIWidget.UpdateCallbacks
// (Final, Native, Public, BlueprintCallable)

void UDoorUIWidget::UpdateCallbacks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DoorUIWidget", "UpdateCallbacks");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.DoorUIWidget.UpdateLocked
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bLocked                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDoorUIWidget::UpdateLocked(bool bLocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DoorUIWidget", "UpdateLocked");

	Params::DoorUIWidget_UpdateLocked Parms{};

	Parms.bLocked = bLocked;

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


// Function Phoenix.DoorUIWidget.UpdatePhxControllerType
// (Event, Public, BlueprintEvent)
// Parameters:
// EPhxControllerType                      ControllerType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDoorUIWidget::UpdatePhxControllerType(EPhxControllerType ControllerType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DoorUIWidget", "UpdatePhxControllerType");

	Params::DoorUIWidget_UpdatePhxControllerType Parms{};

	Parms.ControllerType = ControllerType;

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


// Function Phoenix.PhxAISpawner_Character.DespawnAI
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxAIDespawnReason                     Reason                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAISpawner_Character::DespawnAI(EPhxAIDespawnReason Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawner_Character", "DespawnAI");

	Params::PhxAISpawner_Character_DespawnAI Parms{};

	Parms.Reason = Reason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawner_Character.HandleAISpawned
// (Final, Native, Private)
// Parameters:
// class APhxAICharacter*                  SpawnedAI                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAISpawnResultCode                   ResultCode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SpawnUid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAISpawner_Character::HandleAISpawned(class APhxAICharacter* SpawnedAI, EPhxAISpawnResultCode ResultCode, int32 SpawnUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawner_Character", "HandleAISpawned");

	Params::PhxAISpawner_Character_HandleAISpawned Parms{};

	Parms.SpawnedAI = SpawnedAI;
	Parms.ResultCode = ResultCode;
	Parms.SpawnUid = SpawnUid;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawner_Character.SetCharacterDefinition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class UPhxAICharacterDefinition>InAICharacterDefinitionPtr                             (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InCharacterVariation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAISpawner_Character::SetCharacterDefinition(TSoftObjectPtr<class UPhxAICharacterDefinition> InAICharacterDefinitionPtr, int32 InCharacterVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawner_Character", "SetCharacterDefinition");

	Params::PhxAISpawner_Character_SetCharacterDefinition Parms{};

	Parms.InAICharacterDefinitionPtr = InAICharacterDefinitionPtr;
	Parms.InCharacterVariation = InCharacterVariation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawner_Character.GetLastSpawnedAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxAICharacter*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacter* APhxAISpawner_Character::GetLastSpawnedAI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawner_Character", "GetLastSpawnedAI");

	Params::PhxAISpawner_Character_GetLastSpawnedAI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.KraftonIdCountdownTimer.UpdatePercent
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// float                                   Percent                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKraftonIdCountdownTimer::UpdatePercent(float Percent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KraftonIdCountdownTimer", "UpdatePercent");

	Params::KraftonIdCountdownTimer_UpdatePercent Parms{};

	Parms.Percent = Percent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIShoutBeaconActor.SpawnShoutBeacon
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            ShoutInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BeaconLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      BeaconRadiusCurve                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraSystem*                   OnBeginParticleFX_0                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIShoutBeaconActor::SpawnShoutBeacon(class UObject* WorldContextObject, class APawn* ShoutInstigator, const struct FVector& BeaconLocation, class UCurveFloat* BeaconRadiusCurve, class UNiagaraSystem* OnBeginParticleFX_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIShoutBeaconActor", "SpawnShoutBeacon");

	Params::PhxAIShoutBeaconActor_SpawnShoutBeacon Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ShoutInstigator = ShoutInstigator;
	Parms.BeaconLocation = std::move(BeaconLocation);
	Parms.BeaconRadiusCurve = BeaconRadiusCurve;
	Parms.OnBeginParticleFX_0 = OnBeginParticleFX_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIShoutBeaconActor.SpawnShoutBeaconAttachedToActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            ShoutInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           BeaconAnchor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      BeaconRadiusCurve                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraSystem*                   OnBeginParticleFX_0                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InDetachmentTime                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraSystem*                   AttachedParticleFX                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AttachmentLocationName                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIShoutBeaconActor::SpawnShoutBeaconAttachedToActor(class UObject* WorldContextObject, class APawn* ShoutInstigator, class AActor* BeaconAnchor, class UCurveFloat* BeaconRadiusCurve, class UNiagaraSystem* OnBeginParticleFX_0, float InDetachmentTime, class UNiagaraSystem* AttachedParticleFX, class FName AttachmentLocationName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIShoutBeaconActor", "SpawnShoutBeaconAttachedToActor");

	Params::PhxAIShoutBeaconActor_SpawnShoutBeaconAttachedToActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ShoutInstigator = ShoutInstigator;
	Parms.BeaconAnchor = BeaconAnchor;
	Parms.BeaconRadiusCurve = BeaconRadiusCurve;
	Parms.OnBeginParticleFX_0 = OnBeginParticleFX_0;
	Parms.InDetachmentTime = InDetachmentTime;
	Parms.AttachedParticleFX = AttachedParticleFX;
	Parms.AttachmentLocationName = AttachmentLocationName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryItemsPanel.CanStartConsuming
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInventorySlot*             InSlot                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventoryItemsPanel::CanStartConsuming(const class UInventorySlot* InSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryItemsPanel", "CanStartConsuming");

	Params::InventoryItemsPanel_CanStartConsuming Parms{};

	Parms.InSlot = InSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryItemsPanel.IsConsumableSlot
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInventorySlot*             InSlot                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventoryItemsPanel::IsConsumableSlot(const class UInventorySlot* InSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryItemsPanel", "IsConsumableSlot");

	Params::InventoryItemsPanel_IsConsumableSlot Parms{};

	Parms.InSlot = InSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryItemsPanel.IsHealthSlot
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInventorySlot*             InSlot                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventoryItemsPanel::IsHealthSlot(const class UInventorySlot* InSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryItemsPanel", "IsHealthSlot");

	Params::InventoryItemsPanel_IsHealthSlot Parms{};

	Parms.InSlot = InSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHasEntitlement.HasEntitlement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EPhxEntitlement                         InEntitlement                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxHasEntitlement*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxHasEntitlement* UPhxHasEntitlement::HasEntitlement(EPhxEntitlement InEntitlement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxHasEntitlement", "HasEntitlement");

	Params::PhxHasEntitlement_HasEntitlement Parms{};

	Parms.InEntitlement = InEntitlement;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHasEntitlement.HandleFetchEntitlements
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxEntitlementOwnership&  Ownership                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxHasEntitlement::HandleFetchEntitlements(const struct FPhxEntitlementOwnership& Ownership)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasEntitlement", "HandleFetchEntitlements");

	Params::PhxHasEntitlement_HandleFetchEntitlements Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHasEntitlement.HandleFetchOnlineAccount
// (Final, Native, Protected)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USDSOnlineAccount*          OnlineAccount                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHasEntitlement::HandleFetchOnlineAccount(bool bSuccess, const class USDSOnlineAccount* OnlineAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasEntitlement", "HandleFetchOnlineAccount");

	Params::PhxHasEntitlement_HandleFetchOnlineAccount Parms{};

	Parms.bSuccess = bSuccess;
	Parms.OnlineAccount = OnlineAccount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoComponent.InitializeEcho
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UEchoComponent::InitializeEcho()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoComponent", "InitializeEcho");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoComponent.SetCaptureOffset
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   Offset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEchoComponent::SetCaptureOffset(const struct FVector& Offset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoComponent", "SetCaptureOffset");

	Params::EchoComponent_SetCaptureOffset Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoComponent.UpdateEchoParameters
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USceneCaptureComponent2D*         SceneCaptureComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraComponent*                EchoParticles                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEchoComponent::UpdateEchoParameters(class USceneCaptureComponent2D* SceneCaptureComponent, class UNiagaraComponent* EchoParticles)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoComponent", "UpdateEchoParameters");

	Params::EchoComponent_UpdateEchoParameters Parms{};

	Parms.SceneCaptureComponent = SceneCaptureComponent;
	Parms.EchoParticles = EchoParticles;

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


// Function Phoenix.InteractableProxy.OnInteractionExecuted
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractableProxy::OnInteractionExecuted(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractableProxy", "OnInteractionExecuted");

	Params::InteractableProxy_OnInteractionExecuted Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.OnCharacterInteractExecuted
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::OnCharacterInteractExecuted(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "OnCharacterInteractExecuted");

	Params::PhxScriptedEventActor_OnCharacterInteractExecuted Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.RequestCharacterSwapsForNextCinematic
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TMap<class FName, TSoftClassPtr<class UClass>>&BindingTagsAndRequestedClasses                         (Parm, UObjectWrapper, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::RequestCharacterSwapsForNextCinematic(const TMap<class FName, TSoftClassPtr<class UClass>>& BindingTagsAndRequestedClasses)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "RequestCharacterSwapsForNextCinematic");

	Params::PhxScriptedEventActor_RequestCharacterSwapsForNextCinematic Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.SetAttachInfoOnQTEUsingActorComp
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FQteRequest&                     InQteRequest                                           (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FName                             AttachActorBindingTag                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AttachComponentName                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AttachSocketName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::SetAttachInfoOnQTEUsingActorComp(struct FQteRequest& InQteRequest, class FName AttachActorBindingTag, class FName AttachComponentName, class FName AttachSocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "SetAttachInfoOnQTEUsingActorComp");

	Params::PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorComp Parms{};

	Parms.InQteRequest = std::move(InQteRequest);
	Parms.AttachActorBindingTag = AttachActorBindingTag;
	Parms.AttachComponentName = AttachComponentName;
	Parms.AttachSocketName = AttachSocketName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxScriptedEventActor.SetAttachInfoOnQTEUsingActorSkeletalMesh
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FQteRequest&                     InQteRequest                                           (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FName                             AttachActorBindingTag                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AttachBoneName                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::SetAttachInfoOnQTEUsingActorSkeletalMesh(struct FQteRequest& InQteRequest, class FName AttachActorBindingTag, class FName AttachBoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "SetAttachInfoOnQTEUsingActorSkeletalMesh");

	Params::PhxScriptedEventActor_SetAttachInfoOnQTEUsingActorSkeletalMesh Parms{};

	Parms.InQteRequest = std::move(InQteRequest);
	Parms.AttachActorBindingTag = AttachActorBindingTag;
	Parms.AttachBoneName = AttachBoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxScriptedEventActor.StartCameraLookAroundOverrideInterval
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   EndFrame                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxPitchOverride                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxYawOverride                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LookSpeedOverride                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::StartCameraLookAroundOverrideInterval(int32 EndFrame, float MaxPitchOverride, float MaxYawOverride, float LookSpeedOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "StartCameraLookAroundOverrideInterval");

	Params::PhxScriptedEventActor_StartCameraLookAroundOverrideInterval Parms{};

	Parms.EndFrame = EndFrame;
	Parms.MaxPitchOverride = MaxPitchOverride;
	Parms.MaxYawOverride = MaxYawOverride;
	Parms.LookSpeedOverride = LookSpeedOverride;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.StartPlayerMovementFailureInterval
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   BranchFrame                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MovementInputFrameDuration                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckMoveForward                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckMoveBackward                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckMoveLeft                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckMoveRight                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MovementInputThreshold                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             FailureId                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::StartPlayerMovementFailureInterval(int32 BranchFrame, int32 MovementInputFrameDuration, bool bCheckMoveForward, bool bCheckMoveBackward, bool bCheckMoveLeft, bool bCheckMoveRight, float MovementInputThreshold, class FName FailureId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "StartPlayerMovementFailureInterval");

	Params::PhxScriptedEventActor_StartPlayerMovementFailureInterval Parms{};

	Parms.BranchFrame = BranchFrame;
	Parms.MovementInputFrameDuration = MovementInputFrameDuration;
	Parms.bCheckMoveForward = bCheckMoveForward;
	Parms.bCheckMoveBackward = bCheckMoveBackward;
	Parms.bCheckMoveLeft = bCheckMoveLeft;
	Parms.bCheckMoveRight = bCheckMoveRight;
	Parms.MovementInputThreshold = MovementInputThreshold;
	Parms.FailureId = FailureId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.StartQteFailureInterval
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   BranchFrame                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   QteFrameDuration                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQteRequest&               InQteRequest                                           (Parm, NativeAccessSpecifierPublic)
// class FName                             FailureId                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxCinematicPlaybackActions            FailureAction                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SuccessId                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxCinematicPlaybackActions            SuccessAction                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFailScriptedEventOnFailure                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::StartQteFailureInterval(int32 BranchFrame, int32 QteFrameDuration, const struct FQteRequest& InQteRequest, class FName FailureId, EPhxCinematicPlaybackActions FailureAction, class FName SuccessId, EPhxCinematicPlaybackActions SuccessAction, bool bFailScriptedEventOnFailure)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "StartQteFailureInterval");

	Params::PhxScriptedEventActor_StartQteFailureInterval Parms{};

	Parms.BranchFrame = BranchFrame;
	Parms.QteFrameDuration = QteFrameDuration;
	Parms.InQteRequest = std::move(InQteRequest);
	Parms.FailureId = FailureId;
	Parms.FailureAction = FailureAction;
	Parms.SuccessId = SuccessId;
	Parms.SuccessAction = SuccessAction;
	Parms.bFailScriptedEventOnFailure = bFailScriptedEventOnFailure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.StopLoopingCinematic
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bWaitForCinematicToEnd                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NextCinematicRowOverrideName                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::StopLoopingCinematic(bool bWaitForCinematicToEnd, class FName NextCinematicRowOverrideName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "StopLoopingCinematic");

	Params::PhxScriptedEventActor_StopLoopingCinematic Parms{};

	Parms.bWaitForCinematicToEnd = bWaitForCinematicToEnd;
	Parms.NextCinematicRowOverrideName = NextCinematicRowOverrideName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.StopScriptedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bStopImmediately                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventActor::StopScriptedEvent(bool bStopImmediately)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "StopScriptedEvent");

	Params::PhxScriptedEventActor_StopScriptedEvent Parms{};

	Parms.bStopImmediately = bStopImmediately;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventActor.GetActorBoundToTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             BindingTag                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class AActor>            ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class AActor> APhxScriptedEventActor::GetActorBoundToTag(class FName BindingTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "GetActorBoundToTag");

	Params::PhxScriptedEventActor_GetActorBoundToTag Parms{};

	Parms.BindingTag = BindingTag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxScriptedEventActor.GetCinematicsComponent
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxCinematicsComponent*          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCinematicsComponent* APhxScriptedEventActor::GetCinematicsComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "GetCinematicsComponent");

	Params::PhxScriptedEventActor_GetCinematicsComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxScriptedEventActor.GetListOfLevelSequences
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FSoftObjectPath>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FSoftObjectPath> APhxScriptedEventActor::GetListOfLevelSequences() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "GetListOfLevelSequences");

	Params::PhxScriptedEventActor_GetListOfLevelSequences Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxScriptedEventActor.GetSyncPointFromBindingTag
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName&                      BindingTag                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      OutSyncPoint                                           (Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxScriptedEventActor::GetSyncPointFromBindingTag(const class FName& BindingTag, float Time, struct FTransform* OutSyncPoint) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "GetSyncPointFromBindingTag");

	Params::PhxScriptedEventActor_GetSyncPointFromBindingTag Parms{};

	Parms.BindingTag = BindingTag;
	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxScriptedEventActor.HasValidCinematicData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxScriptedEventActor::HasValidCinematicData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "HasValidCinematicData");

	Params::PhxScriptedEventActor_HasValidCinematicData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxScriptedEventActor.IsReadyForPlayback
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxScriptedEventActor::IsReadyForPlayback() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventActor", "IsReadyForPlayback");

	Params::PhxScriptedEventActor_IsReadyForPlayback Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.EchoProjector.AreEchoComponentsReady
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEchoProjector::AreEchoComponentsReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "AreEchoComponentsReady");

	Params::EchoProjector_AreEchoComponentsReady Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.EchoProjector.DisableProjector
// (Final, Native, Public, BlueprintCallable)

void AEchoProjector::DisableProjector()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "DisableProjector");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.EnableProjector
// (Final, Native, Public, BlueprintCallable)

void AEchoProjector::EnableProjector()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "EnableProjector");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.OnEchoSequenceFinished
// (Final, Native, Protected)

void AEchoProjector::OnEchoSequenceFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "OnEchoSequenceFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.OnInteractionAreaBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AEchoProjector::OnInteractionAreaBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "OnInteractionAreaBeginOverlap");

	Params::EchoProjector_OnInteractionAreaBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.OnInteractionAreaEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEchoProjector::OnInteractionAreaEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "OnInteractionAreaEndOverlap");

	Params::EchoProjector_OnInteractionAreaEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.OnTriggerVolumeBeginOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEchoProjector::OnTriggerVolumeBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "OnTriggerVolumeBeginOverlap");

	Params::EchoProjector_OnTriggerVolumeBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.RequestPlay
// (Final, Native, Public, BlueprintCallable)

void AEchoProjector::RequestPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "RequestPlay");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.RequestRestart
// (Final, Native, Public, BlueprintCallable)

void AEchoProjector::RequestRestart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "RequestRestart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.RequestShutdown
// (Final, Native, Public, BlueprintCallable)

void AEchoProjector::RequestShutdown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "RequestShutdown");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.RequestTogglePause
// (Final, Native, Public, BlueprintCallable)

void AEchoProjector::RequestTogglePause()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "RequestTogglePause");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.SetEchoAlertEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEchoProjector::SetEchoAlertEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "SetEchoAlertEnabled");

	Params::EchoProjector_SetEchoAlertEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.SetEchoUIControls
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEchoProjector::SetEchoUIControls(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "SetEchoUIControls");

	Params::EchoProjector_SetEchoUIControls Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoProjector.GetEchoComponents
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class UEchoComponent*>     ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

const TArray<class UEchoComponent*> AEchoProjector::GetEchoComponents() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoProjector", "GetEchoComponents");

	Params::EchoProjector_GetEchoComponents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.EchoState.BeginOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEchoState::BeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoState", "BeginOverlap");

	Params::EchoState_BeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.EchoUI.GetNormalizedDistanceToProjector
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AEchoUI::GetNormalizedDistanceToProjector()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EchoUI", "GetNormalizedDistanceToProjector");

	Params::EchoUI_GetNormalizedDistanceToProjector Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryWeaponDetails.SetDetailsVisible
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryWeaponDetails::SetDetailsVisible(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryWeaponDetails", "SetDetailsVisible");

	Params::InventoryWeaponDetails_SetDetailsVisible Parms{};

	Parms.bVisible = bVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryWeaponDetails.GetAdjacentSlot
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const class UInventorySlot*             InSlot                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInventorySlot*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventorySlot* UInventoryWeaponDetails::GetAdjacentSlot(const class UInventorySlot* InSlot, EInputDirection Direction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryWeaponDetails", "GetAdjacentSlot");

	Params::InventoryWeaponDetails_GetAdjacentSlot Parms{};

	Parms.InSlot = InSlot;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryWeaponDetails.GetSelectedSlot
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UInventorySlot*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventorySlot* UInventoryWeaponDetails::GetSelectedSlot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryWeaponDetails", "GetSelectedSlot");

	Params::InventoryWeaponDetails_GetSelectedSlot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLockPickPuzzle.AutoComplete
// (Final, Native, Public, BlueprintCallable)

void APhxLockPickPuzzle::AutoComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLockPickPuzzle", "AutoComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLockPickPuzzle.HandleInteraction
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLockPickPuzzle::HandleInteraction(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLockPickPuzzle", "HandleInteraction");

	Params::PhxLockPickPuzzle_HandleInteraction Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSendEnemyDeathTelemetry.SendEnemyDeathTelemetry
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APhxCharacter*              Enemy                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSendEnemyDeathTelemetry*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSendEnemyDeathTelemetry* UPhxSendEnemyDeathTelemetry::SendEnemyDeathTelemetry(const class UObject* WorldContextObject, const class APhxCharacter* Character, const class APhxCharacter* Enemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSendEnemyDeathTelemetry", "SendEnemyDeathTelemetry");

	Params::PhxSendEnemyDeathTelemetry_SendEnemyDeathTelemetry Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Character = Character;
	Parms.Enemy = Enemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPuzzleSwitch.CanInteract
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPuzzleSwitch::CanInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "CanInteract");

	Params::PhxPuzzleSwitch_CanInteract Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPuzzleSwitch.IsPuzzleSolved
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPuzzleSwitch::IsPuzzleSolved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "IsPuzzleSolved");

	Params::PhxPuzzleSwitch_IsPuzzleSolved Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPuzzleSwitch.OnAnimNotify
// (Event, Public, BlueprintEvent)
// Parameters:
// EPhxAnimNotify                          Notify                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleSwitch::OnAnimNotify(EPhxAnimNotify Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "OnAnimNotify");

	Params::PhxPuzzleSwitch_OnAnimNotify Parms{};

	Parms.Notify = Notify;

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


// Function Phoenix.PhxPuzzleSwitch.OnCancelledInteract
// (Event, Public, BlueprintEvent)

void APhxPuzzleSwitch::OnCancelledInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "OnCancelledInteract");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPuzzleSwitch.OnFailedInteract
// (Event, Public, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleSwitch::OnFailedInteract(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "OnFailedInteract");

	Params::PhxPuzzleSwitch_OnFailedInteract Parms{};

	Parms.InteractedBy = InteractedBy;

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


// Function Phoenix.PhxPuzzleSwitch.OnInteract
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleSwitch::OnInteract(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "OnInteract");

	Params::PhxPuzzleSwitch_OnInteract Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleSwitch.OnPuzzleSolved
// (Event, Public, BlueprintEvent)

void APhxPuzzleSwitch::OnPuzzleSolved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "OnPuzzleSolved");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPuzzleSwitch.PlayMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FName                       StartSectionName                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleSwitch::PlayMontage(const class FName StartSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "PlayMontage");

	Params::PhxPuzzleSwitch_PlayMontage Parms{};

	Parms.StartSectionName = StartSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleSwitch.SetInteractionEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleSwitch::SetInteractionEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "SetInteractionEnabled");

	Params::PhxPuzzleSwitch_SetInteractionEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleSwitch.SetState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const int32                             NewState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleSwitch::SetState(const int32 NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "SetState");

	Params::PhxPuzzleSwitch_SetState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleSwitch.GetInteractionRequiresShiv
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPuzzleSwitch::GetInteractionRequiresShiv() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "GetInteractionRequiresShiv");

	Params::PhxPuzzleSwitch_GetInteractionRequiresShiv Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPuzzleSwitch.GetMontageSectionToPlayOnInteract
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName APhxPuzzleSwitch::GetMontageSectionToPlayOnInteract() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "GetMontageSectionToPlayOnInteract");

	Params::PhxPuzzleSwitch_GetMontageSectionToPlayOnInteract Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPuzzleSwitch.GetMontageSectionToPlayOnStart
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName APhxPuzzleSwitch::GetMontageSectionToPlayOnStart() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "GetMontageSectionToPlayOnStart");

	Params::PhxPuzzleSwitch_GetMontageSectionToPlayOnStart Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPuzzleSwitch.GetSkeletalMesh
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* APhxPuzzleSwitch::GetSkeletalMesh() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleSwitch", "GetSkeletalMesh");

	Params::PhxPuzzleSwitch_GetSkeletalMesh Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPuzzleSwitch.GetState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxPuzzleSwitch::GetState() const
{
	static class UFunction* Func = nullptr;

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

	Params::PhxPuzzleSwitch_GetState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GameplayInputState.OnAimRequested
// (Final, Native, Protected)

void UGameplayInputState::OnAimRequested()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameplayInputState", "OnAimRequested");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GameplayInputState.RequestInventoryToggle
// (Final, Native, Protected)

void UGameplayInputState::RequestInventoryToggle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameplayInputState", "RequestInventoryToggle");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GameplayInputState.ShowTutorialInInventory
// (Final, Native, Public)

void UGameplayInputState::ShowTutorialInInventory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameplayInputState", "ShowTutorialInInventory");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.GameplayInputState.ToggleInventory
// (Final, Native, Protected)

void UGameplayInputState::ToggleInventory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameplayInputState", "ToggleInventory");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleCrate.HandleProximityChanged
// (Final, Native, Protected)
// Parameters:
// EInteractableProximity                  Promity                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInteractableProximity                  PreviousProximity                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleCrate::HandleProximityChanged(EInteractableProximity Promity, EInteractableProximity PreviousProximity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleCrate", "HandleProximityChanged");

	Params::PhxPuzzleCrate_HandleProximityChanged Parms{};

	Parms.Promity = Promity;
	Parms.PreviousProximity = PreviousProximity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleCrate.OnCrateCollided
// (Event, Public, BlueprintEvent)
// Parameters:
// const struct FHitResult&                HitInfo                                                (Parm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxPuzzleCrate::OnCrateCollided(const struct FHitResult& HitInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleCrate", "OnCrateCollided");

	Params::PhxPuzzleCrate_OnCrateCollided Parms{};

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

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


// Function Phoenix.PhxPuzzleCrate.OnCrateLanded
// (Event, Protected, BlueprintEvent)

void APhxPuzzleCrate::OnCrateLanded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleCrate", "OnCrateLanded");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPuzzleCrate.OnCrateLiftEnded
// (Event, Protected, BlueprintEvent)

void APhxPuzzleCrate::OnCrateLiftEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleCrate", "OnCrateLiftEnded");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPuzzleCrate.OnCrateLiftStarted
// (Event, Protected, BlueprintEvent)

void APhxPuzzleCrate::OnCrateLiftStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleCrate", "OnCrateLiftStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPuzzleCrate.SetState
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EMovableCrateState                      State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleCrate::SetState(EMovableCrateState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleCrate", "SetState");

	Params::PhxPuzzleCrate_SetState Parms{};

	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HDRGammaScreenWidget.SetBlackPointCorrectionSliderPosition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBroadcast                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHDRGammaScreenWidget::SetBlackPointCorrectionSliderPosition(float InValue, bool bBroadcast)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HDRGammaScreenWidget", "SetBlackPointCorrectionSliderPosition");

	Params::HDRGammaScreenWidget_SetBlackPointCorrectionSliderPosition Parms{};

	Parms.InValue = InValue;
	Parms.bBroadcast = bBroadcast;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.Compare
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FDateTime&                 InTime                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      InName                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameButton::Compare(const struct FDateTime& InTime, const class FText& InName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "Compare");

	Params::PhxSaveGameButton_Compare Parms{};

	Parms.InTime = std::move(InTime);
	Parms.InName = std::move(InName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameButton.SetDate
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetDate(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetDate");

	Params::PhxSaveGameButton_SetDate Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetGameType
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetGameType(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetGameType");

	Params::PhxSaveGameButton_SetGameType Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetLevel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetLevel(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetLevel");

	Params::PhxSaveGameButton_SetLevel Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetLocation
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetLocation(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetLocation");

	Params::PhxSaveGameButton_SetLocation Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetModifiedTime
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FDateTime&                 InTime                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetModifiedTime(const struct FDateTime& InTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetModifiedTime");

	Params::PhxSaveGameButton_SetModifiedTime Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetName
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetName(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetName");

	Params::PhxSaveGameButton_SetName Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetSaveSlotName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    inString                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetSaveSlotName(const class FString& inString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetSaveSlotName");

	Params::PhxSaveGameButton_SetSaveSlotName Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetSaveType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EPhxSaveGameType                  InSaveType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetSaveType(const EPhxSaveGameType InSaveType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetSaveType");

	Params::PhxSaveGameButton_SetSaveType Parms{};

	Parms.InSaveType = InSaveType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetTime
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetTime(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetTime");

	Params::PhxSaveGameButton_SetTime Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameButton.SetTotalPlayTime
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             InTime                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameButton::SetTotalPlayTime(const float InTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameButton", "SetTotalPlayTime");

	Params::PhxSaveGameButton_SetTotalPlayTime Parms{};

	Parms.InTime = InTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSplineMesh.RegenerateMesh
// (Final, Native, Public, BlueprintCallable)

void UPhxSplineMesh::RegenerateMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSplineMesh", "RegenerateMesh");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSplineMesh.GetSpline
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USplineComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USplineComponent* UPhxSplineMesh::GetSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSplineMesh", "GetSpline");

	Params::PhxSplineMesh_GetSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GlowNode.OnPerceived
// (Final, Native, Public)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAIStimulus&               Stimulus                                               (Parm, NoDestructor, NativeAccessSpecifierPublic)

void AGlowNode::OnPerceived(class AActor* Actor, const struct FAIStimulus& Stimulus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GlowNode", "OnPerceived");

	Params::GlowNode_OnPerceived Parms{};

	Parms.Actor = Actor;
	Parms.Stimulus = std::move(Stimulus);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TargetComponent.SetIsMeleeTargetable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bTargetable                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTargetComponent::SetIsMeleeTargetable(bool bTargetable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetComponent", "SetIsMeleeTargetable");

	Params::TargetComponent_SetIsMeleeTargetable Parms{};

	Parms.bTargetable = bTargetable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TargetComponent.GetIsMeleeTargetable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTargetComponent::GetIsMeleeTargetable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetComponent", "GetIsMeleeTargetable");

	Params::TargetComponent_GetIsMeleeTargetable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCameraManager.DelayCameraFade
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                                   DelayDuration                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FromAlpha                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ToAlpha                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldFadeAudio                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bHoldWhenFinished                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCameraManager::DelayCameraFade(float DelayDuration, float FromAlpha, float ToAlpha, float Duration, const struct FLinearColor& Color, bool bShouldFadeAudio, bool bHoldWhenFinished)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "DelayCameraFade");

	Params::PhxPlayerCameraManager_DelayCameraFade Parms{};

	Parms.DelayDuration = DelayDuration;
	Parms.FromAlpha = FromAlpha;
	Parms.ToAlpha = ToAlpha;
	Parms.Duration = Duration;
	Parms.Color = std::move(Color);
	Parms.bShouldFadeAudio = bShouldFadeAudio;
	Parms.bHoldWhenFinished = bHoldWhenFinished;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCameraManager.GetCurrentPitchPercentOfMaxSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxPlayerCameraManager::GetCurrentPitchPercentOfMaxSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "GetCurrentPitchPercentOfMaxSpeed");

	Params::PhxPlayerCameraManager_GetCurrentPitchPercentOfMaxSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCameraManager.GetCurrentPitchSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxPlayerCameraManager::GetCurrentPitchSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "GetCurrentPitchSpeed");

	Params::PhxPlayerCameraManager_GetCurrentPitchSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCameraManager.GetCurrentYawPercentOfMaxSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxPlayerCameraManager::GetCurrentYawPercentOfMaxSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "GetCurrentYawPercentOfMaxSpeed");

	Params::PhxPlayerCameraManager_GetCurrentYawPercentOfMaxSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCameraManager.GetCurrentYawSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxPlayerCameraManager::GetCurrentYawSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "GetCurrentYawSpeed");

	Params::PhxPlayerCameraManager_GetCurrentYawSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCameraManager.GetMaxPitchSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxPlayerCameraManager::GetMaxPitchSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "GetMaxPitchSpeed");

	Params::PhxPlayerCameraManager_GetMaxPitchSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCameraManager.GetMaxYawSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxPlayerCameraManager::GetMaxYawSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "GetMaxYawSpeed");

	Params::PhxPlayerCameraManager_GetMaxYawSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCameraManager.GetCurrentFadeAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxPlayerCameraManager::GetCurrentFadeAmount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCameraManager", "GetCurrentFadeAmount");

	Params::PhxPlayerCameraManager_GetCurrentFadeAmount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRangedWeapon.HideAmmoUI
// (Final, Native, Public, BlueprintCallable)

void APhxRangedWeapon::HideAmmoUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "HideAmmoUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRangedWeapon.OnAbortADS
// (Event, Protected, BlueprintEvent)

void APhxRangedWeapon::OnAbortADS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnAbortADS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.OnBeginADS
// (Event, Protected, BlueprintEvent)

void APhxRangedWeapon::OnBeginADS()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnBeginADS");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.OnBeginFiring
// (Event, Public, BlueprintEvent)

void APhxRangedWeapon::OnBeginFiring()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnBeginFiring");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.OnBeginReload
// (Event, Public, BlueprintEvent)

void APhxRangedWeapon::OnBeginReload()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnBeginReload");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.OnEndFiring
// (Event, Public, BlueprintEvent)

void APhxRangedWeapon::OnEndFiring()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnEndFiring");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.OnEndReload
// (Event, Public, BlueprintEvent)

void APhxRangedWeapon::OnEndReload()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnEndReload");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.OnHit
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TheBaseDamage                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitFromDirection                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AController*                      EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UDamageType>          DamageTypeClass                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxRangedWeapon::OnHit(class AActor* DamagedActor, float TheBaseDamage, const struct FVector& HitFromDirection, const struct FHitResult& HitInfo, class AController* EventInstigator, class AActor* DamageCauser, TSubclassOf<class UDamageType> DamageTypeClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnHit");

	Params::PhxRangedWeapon_OnHit Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.TheBaseDamage = TheBaseDamage;
	Parms.HitFromDirection = std::move(HitFromDirection);
	Parms.HitInfo = std::move(HitInfo);
	Parms.EventInstigator = EventInstigator;
	Parms.DamageCauser = DamageCauser;
	Parms.DamageTypeClass = DamageTypeClass;

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


// Function Phoenix.PhxRangedWeapon.OnSEBegin
// (Event, Public, BlueprintEvent)

void APhxRangedWeapon::OnSEBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnSEBegin");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.OnSEEnd
// (Event, Public, BlueprintEvent)

void APhxRangedWeapon::OnSEEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "OnSEEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRangedWeapon.ShowAmmoUI
// (Final, Native, Public, BlueprintCallable)

void APhxRangedWeapon::ShowAmmoUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "ShowAmmoUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRangedWeapon.StartFire
// (Native, Public, BlueprintCallable)

void APhxRangedWeapon::StartFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "StartFire");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRangedWeapon.StopFire
// (Native, Public, BlueprintCallable)

void APhxRangedWeapon::StopFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "StopFire");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRangedWeapon.GetAmmoComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxAmmoComponent*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAmmoComponent* APhxRangedWeapon::GetAmmoComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "GetAmmoComponent");

	Params::PhxRangedWeapon_GetAmmoComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRangedWeapon.GetIsFiring
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxRangedWeapon::GetIsFiring() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "GetIsFiring");

	Params::PhxRangedWeapon_GetIsFiring Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRangedWeapon.GetIsInADS
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxRangedWeapon::GetIsInADS() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "GetIsInADS");

	Params::PhxRangedWeapon_GetIsInADS Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRangedWeapon.GetOwningCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCharacter* APhxRangedWeapon::GetOwningCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRangedWeapon", "GetOwningCharacter");

	Params::PhxRangedWeapon_GetOwningCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GRPWeapon.BP_UpdateChargeVisuals
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   ChargeLevel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AGRPWeapon::BP_UpdateChargeVisuals(float ChargeLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "BP_UpdateChargeVisuals");

	Params::GRPWeapon_BP_UpdateChargeVisuals Parms{};

	Parms.ChargeLevel = ChargeLevel;

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


// Function Phoenix.GRPWeapon.GetGRPRechargeDelayAlpha
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AGRPWeapon::GetGRPRechargeDelayAlpha()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "GetGRPRechargeDelayAlpha");

	Params::GRPWeapon_GetGRPRechargeDelayAlpha Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GRPWeapon.OnGRPGrabFailInsufficientCharge
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPGrabFailInsufficientCharge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPGrabFailInsufficientCharge");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPNoValidTargetFound
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPNoValidTargetFound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPNoValidTargetFound");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponChargeReachesEmpty
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPWeaponChargeReachesEmpty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponChargeReachesEmpty");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponChargeReachesFull
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPWeaponChargeReachesFull()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponChargeReachesFull");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponChargingResumes
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPWeaponChargingResumes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponChargingResumes");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponEnterHeld
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPWeaponEnterHeld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponEnterHeld");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponEnterLaunched
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPWeaponEnterLaunched()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponEnterLaunched");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponEnterPulled
// (Event, Public, BlueprintEvent)

void AGRPWeapon::OnGRPWeaponEnterPulled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponEnterPulled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponRefillWithBattery
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AGRPWeapon::OnGRPWeaponRefillWithBattery()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponRefillWithBattery");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.GRPWeapon.OnGRPWeaponRelease
// (Event, Public, BlueprintEvent)
// Parameters:
// EGRPReleaseReason                       ReleaseReason                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AGRPWeapon::OnGRPWeaponRelease(EGRPReleaseReason ReleaseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "OnGRPWeaponRelease");

	Params::GRPWeapon_OnGRPWeaponRelease Parms{};

	Parms.ReleaseReason = ReleaseReason;

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


// Function Phoenix.GRPWeapon.GetChargeComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGRPChargeComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGRPChargeComponent* AGRPWeapon::GetChargeComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "GetChargeComponent");

	Params::GRPWeapon_GetChargeComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GRPWeapon.GetGRPLaunchLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGRPLaunchLevel                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGRPLaunchLevel AGRPWeapon::GetGRPLaunchLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "GetGRPLaunchLevel");

	Params::GRPWeapon_GetGRPLaunchLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GRPWeapon.GetGRPTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AGRPWeapon::GetGRPTarget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "GetGRPTarget");

	Params::GRPWeapon_GetGRPTarget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GRPWeapon.GetGRPWeaponHoldAttachOffset
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AGRPWeapon::GetGRPWeaponHoldAttachOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "GetGRPWeaponHoldAttachOffset");

	Params::GRPWeapon_GetGRPWeaponHoldAttachOffset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.GRPWeapon.GetGRPWeaponSocketLocationAndRotation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FQuat*                           OutRotation                                            (Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AGRPWeapon::GetGRPWeaponSocketLocationAndRotation(class FName SocketName, struct FVector* OutLocation, struct FQuat* OutRotation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GRPWeapon", "GetGRPWeaponSocketLocationAndRotation");

	Params::GRPWeapon_GetGRPWeaponSocketLocationAndRotation Parms{};

	Parms.SocketName = SocketName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.HarvestableComponent.BP_OnHarvestFinished
// (Event, Protected, BlueprintEvent)

void UHarvestableComponent::BP_OnHarvestFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HarvestableComponent", "BP_OnHarvestFinished");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HarvestableComponent.BP_OnOwnerDeath
// (Event, Protected, BlueprintEvent)

void UHarvestableComponent::BP_OnOwnerDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HarvestableComponent", "BP_OnOwnerDeath");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HarvestableComponent.FinishHarvest
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    Harvester                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHarvestableComponent::FinishHarvest(class APhxCharacter* Harvester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HarvestableComponent", "FinishHarvest");

	Params::HarvestableComponent_FinishHarvest Parms{};

	Parms.Harvester = Harvester;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HarvestableComponent.OnOwnerDeath
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHarvestableComponent::OnOwnerDeath(class APhxCharacter* DeadCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HarvestableComponent", "OnOwnerDeath");

	Params::HarvestableComponent_OnOwnerDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxStompableInterface.CanTakeStompDamage
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IPhxStompableInterface::CanTakeStompDamage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxStompableInterface", "CanTakeStompDamage");

	Params::PhxStompableInterface_CanTakeStompDamage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ContextualAnimTargetInterface.GetContextualAnimTargetComponent
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class ULightWeightContextualAnimTargetComponent*ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULightWeightContextualAnimTargetComponent* IContextualAnimTargetInterface::GetContextualAnimTargetComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("ContextualAnimTargetInterface", "GetContextualAnimTargetComponent");

	Params::ContextualAnimTargetInterface_GetContextualAnimTargetComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HealthHUD.GetMeterColor
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FLinearColor AHealthHUD::GetMeterColor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthHUD", "GetMeterColor");

	Params::HealthHUD_GetMeterColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HealthHUD.GetWidgetLocalCorners
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWidgetComponent*                 WidgetComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FVector>            ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

const TArray<struct FVector> AHealthHUD::GetWidgetLocalCorners(class UWidgetComponent* WidgetComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthHUD", "GetWidgetLocalCorners");

	Params::HealthHUD_GetWidgetLocalCorners Parms{};

	Parms.WidgetComponent = WidgetComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HealthHUD.GetWidgetWorldCorners
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWidgetComponent*                 WidgetComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FVector>            ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

const TArray<struct FVector> AHealthHUD::GetWidgetWorldCorners(class UWidgetComponent* WidgetComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthHUD", "GetWidgetWorldCorners");

	Params::HealthHUD_GetWidgetWorldCorners Parms{};

	Parms.WidgetComponent = WidgetComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HealthHUD.HandleOnHealthChanged
// (Final, Native, Protected)
// Parameters:
// class UPhxHealthComponent*              CallingHealthComp                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AHealthHUD::HandleOnHealthChanged(class UPhxHealthComponent* CallingHealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthHUD", "HandleOnHealthChanged");

	Params::HealthHUD_HandleOnHealthChanged Parms{};

	Parms.CallingHealthComp = CallingHealthComp;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HealthHUD.OnCriticalSoundEvent
// (Final, Native, Protected)
// Parameters:
// EAkCallbackType                         CallbackType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  CallbackInfo                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AHealthHUD::OnCriticalSoundEvent(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthHUD", "OnCriticalSoundEvent");

	Params::HealthHUD_OnCriticalSoundEvent Parms{};

	Parms.CallbackType = CallbackType;
	Parms.CallbackInfo = CallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HealthHUD.ToggleHologram
// (Final, Native, Public, BlueprintCallable)

void AHealthHUD::ToggleHologram()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HealthHUD", "ToggleHologram");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HeroInputState.TriggerCuedComboForAttack
// (Final, Native, Protected)
// Parameters:
// class UMeleeAttackState*                AttackState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHeroInputState::TriggerCuedComboForAttack(class UMeleeAttackState* AttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HeroInputState", "TriggerCuedComboForAttack");

	Params::HeroInputState_TriggerCuedComboForAttack Parms{};

	Parms.AttackState = AttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HeroInputState.TriggerCuedComboForDefensiveReact
// (Final, Native, Protected)
// Parameters:
// class UMontageReactState*               ReactState                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHeroInputState::TriggerCuedComboForDefensiveReact(class UMontageReactState* ReactState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HeroInputState", "TriggerCuedComboForDefensiveReact");

	Params::HeroInputState_TriggerCuedComboForDefensiveReact Parms{};

	Parms.ReactState = ReactState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HeroInputState.TriggerCuedExplicitComboForAttack
// (Final, Native, Protected)
// Parameters:
// class UMeleeAttackState*                AttackState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHeroInputState::TriggerCuedExplicitComboForAttack(class UMeleeAttackState* AttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HeroInputState", "TriggerCuedExplicitComboForAttack");

	Params::HeroInputState_TriggerCuedExplicitComboForAttack Parms{};

	Parms.AttackState = AttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSkeletalOptimize.EnableOptimize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInit                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSkeletalOptimize::EnableOptimize(bool bEnable, bool bInit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSkeletalOptimize", "EnableOptimize");

	Params::PhxSkeletalOptimize_EnableOptimize Parms{};

	Parms.bEnable = bEnable;
	Parms.bInit = bInit;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSkeletalOptimize.OnPlayerScriptedEventEnd
// (Final, Native, Protected)

void UPhxSkeletalOptimize::OnPlayerScriptedEventEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSkeletalOptimize", "OnPlayerScriptedEventEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSkeletalOptimize.OnPlayerScriptedEventStart
// (Final, Native, Protected)

void UPhxSkeletalOptimize::OnPlayerScriptedEventStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSkeletalOptimize", "OnPlayerScriptedEventStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.IsEnabled
// (Final, Native, Static, Public)
// Parameters:
// const bool                              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const bool UHitCounter::IsEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HitCounter", "IsEnabled");

	Params::HitCounter_IsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HitCounter.PrintStatsToLog
// (Final, Native, Static, Public)
// Parameters:
// class UWorld*                           CurrentWorld                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             PlayerIndex                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHitCounter::PrintStatsToLog(class UWorld* CurrentWorld, const int32 PlayerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HitCounter", "PrintStatsToLog");

	Params::HitCounter_PrintStatsToLog Parms{};

	Parms.CurrentWorld = CurrentWorld;
	Parms.PlayerIndex = PlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.ResetStats
// (Final, Native, Static, Public)
// Parameters:
// class UWorld*                           CurrentWorld                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             PlayerIndex                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHitCounter::ResetStats(class UWorld* CurrentWorld, const int32 PlayerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HitCounter", "ResetStats");

	Params::HitCounter_ResetStats Parms{};

	Parms.CurrentWorld = CurrentWorld;
	Parms.PlayerIndex = PlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.SetTimerTime
// (Final, Native, Static, Public)
// Parameters:
// const float                             Time                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHitCounter::SetTimerTime(const float Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HitCounter", "SetTimerTime");

	Params::HitCounter_SetTimerTime Parms{};

	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.ToggleCounterTimerType
// (Final, Native, Static, Public)

void UHitCounter::ToggleCounterTimerType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HitCounter", "ToggleCounterTimerType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.ToggleHitCounterLogging
// (Final, Native, Static, Public)

void UHitCounter::ToggleHitCounterLogging()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HitCounter", "ToggleHitCounterLogging");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.InitConsoleCommands
// (Final, Native, Private)

void UHitCounter::InitConsoleCommands()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HitCounter", "InitConsoleCommands");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.LogHit
// (Final, Native, Public)
// Parameters:
// const class FName                       BoneHit                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    GunDebugName                                           (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHitCounter::LogHit(const class FName BoneHit, const class FString& GunDebugName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HitCounter", "LogHit");

	Params::HitCounter_LogHit Parms{};

	Parms.BoneHit = BoneHit;
	Parms.GunDebugName = std::move(GunDebugName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.LogShot
// (Final, Native, Public)
// Parameters:
// const class FString&                    GunDebugName                                           (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHitCounter::LogShot(const class FString& GunDebugName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HitCounter", "LogShot");

	Params::HitCounter_LogShot Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.PrintStatsToScreen
// (Final, Native, Public)
// Parameters:
// const float                             Time                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHitCounter::PrintStatsToScreen(const float Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HitCounter", "PrintStatsToScreen");

	Params::HitCounter_PrintStatsToScreen Parms{};

	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.SetWorld
// (Final, Native, Public)
// Parameters:
// class UWorld*                           NewWorld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHitCounter::SetWorld(class UWorld* NewWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HitCounter", "SetWorld");

	Params::HitCounter_SetWorld Parms{};

	Parms.NewWorld = NewWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.StartTimerOnStartFiring
// (Final, Native, Public)

void UHitCounter::StartTimerOnStartFiring()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HitCounter", "StartTimerOnStartFiring");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HitCounter.StopTimerOnStopFiring
// (Final, Native, Public)

void UHitCounter::StopTimerOnStopFiring()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HitCounter", "StopTimerOnStopFiring");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HologramPrintingMesh.AbortPrint
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::AbortPrint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "AbortPrint");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HologramPrintingMesh.GetPrinterSkeletalMeshComp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* AHologramPrintingMesh::GetPrinterSkeletalMeshComp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "GetPrinterSkeletalMeshComp");

	Params::HologramPrintingMesh_GetPrinterSkeletalMeshComp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.HologramPrintingMesh.HideMesh
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::HideMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "HideMesh");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HologramPrintingMesh.OnDeactivated
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::OnDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "OnDeactivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HologramPrintingMesh.PrepareNiagaraSystem
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::PrepareNiagaraSystem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "PrepareNiagaraSystem");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HologramPrintingMesh.SetHologramMesh
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// class USkeletalMesh*                    NewHologramSkeletalMesh                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMesh*                      NewHologramStaticMesh                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                NewTransform                                           (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AHologramPrintingMesh::SetHologramMesh(class USkeletalMesh* NewHologramSkeletalMesh, class UStaticMesh* NewHologramStaticMesh, const struct FTransform& NewTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "SetHologramMesh");

	Params::HologramPrintingMesh_SetHologramMesh Parms{};

	Parms.NewHologramSkeletalMesh = NewHologramSkeletalMesh;
	Parms.NewHologramStaticMesh = NewHologramStaticMesh;
	Parms.NewTransform = std::move(NewTransform);

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


// Function Phoenix.HologramPrintingMesh.SetPrinterSkeletalMeshComp
// (Final, Native, Public)
// Parameters:
// class USkeletalMeshComponent*           NewSkeletalMesh                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AHologramPrintingMesh::SetPrinterSkeletalMeshComp(class USkeletalMeshComponent* NewSkeletalMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "SetPrinterSkeletalMeshComp");

	Params::HologramPrintingMesh_SetPrinterSkeletalMeshComp Parms{};

	Parms.NewSkeletalMesh = NewSkeletalMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.HologramPrintingMesh.ShowLowerReceiver
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::ShowLowerReceiver()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "ShowLowerReceiver");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HologramPrintingMesh.ShowPrintingMesh
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::ShowPrintingMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "ShowPrintingMesh");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HologramPrintingMesh.StartPrint
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::StartPrint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "StartPrint");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.HologramPrintingMesh.StopPrint
// (Event, Public, BlueprintEvent)

void AHologramPrintingMesh::StopPrint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HologramPrintingMesh", "StopPrint");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMovementSplineObstacleInterface.OnMovementSplineSubjectHitObstacle
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AActor*                           MovementActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxMovementSpline*               MovementSpline                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxMovementSplineObstacleInterface::OnMovementSplineSubjectHitObstacle(const struct FHitResult& HitResult, class AActor* MovementActor, class APhxMovementSpline* MovementSpline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxMovementSplineObstacleInterface", "OnMovementSplineSubjectHitObstacle");

	Params::PhxMovementSplineObstacleInterface_OnMovementSplineSubjectHitObstacle Parms{};

	Parms.HitResult = std::move(HitResult);
	Parms.MovementActor = MovementActor;
	Parms.MovementSpline = MovementSpline;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractablePickupComponent.GetEquippableClass
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class AEquippable>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class AEquippable> UInteractablePickupComponent::GetEquippableClass()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractablePickupComponent", "GetEquippableClass");

	Params::InteractablePickupComponent_GetEquippableClass Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InteractablePickupComponent.SetEquippableClass
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class AEquippable>          NewEquippableClass                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractablePickupComponent::SetEquippableClass(TSubclassOf<class AEquippable> NewEquippableClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractablePickupComponent", "SetEquippableClass");

	Params::InteractablePickupComponent_SetEquippableClass Parms{};

	Parms.NewEquippableClass = NewEquippableClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractablePickupComponent.ShouldDestroyPickupActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInteractablePickupComponent::ShouldDestroyPickupActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractablePickupComponent", "ShouldDestroyPickupActor");

	Params::InteractablePickupComponent_ShouldDestroyPickupActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTexMemUsageManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxTexMemUsageManager*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxTexMemUsageManager* UPhxTexMemUsageManager::Get(const class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxTexMemUsageManager", "Get");

	Params::PhxTexMemUsageManager_Get Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTexMemUsageManager.ToggleUI
// (Final, Native, Public, BlueprintCallable)

void UPhxTexMemUsageManager::ToggleUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTexMemUsageManager", "ToggleUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSnowcatSpline.StartSnowcatDrive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxSnowcat*                      InSnowcat                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSnowcatSpline::StartSnowcatDrive(class APhxSnowcat* InSnowcat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcatSpline", "StartSnowcatDrive");

	Params::PhxSnowcatSpline_StartSnowcatDrive Parms{};

	Parms.InSnowcat = InSnowcat;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractionWidget.OnConstruct
// (Final, Native, Protected, BlueprintCallable)

void UInteractionWidget::OnConstruct()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionWidget", "OnConstruct");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractionWidget.SetIcon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UTexture*                         NewInputIconTexture                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionWidget::SetIcon(class UTexture* NewInputIconTexture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionWidget", "SetIcon");

	Params::InteractionWidget_SetIcon Parms{};

	Parms.NewInputIconTexture = NewInputIconTexture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InteractionWidget.SetProgress
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   ProgressPercentage                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionWidget::SetProgress(float ProgressPercentage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionWidget", "SetProgress");

	Params::InteractionWidget_SetProgress Parms{};

	Parms.ProgressPercentage = ProgressPercentage;

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


// Function Phoenix.InventoryArsenalPanel.IsSwappableSlot
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UArsenalSlot*               InSlot                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInventoryArsenalPanel::IsSwappableSlot(const class UArsenalSlot* InSlot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryArsenalPanel", "IsSwappableSlot");

	Params::InventoryArsenalPanel_IsSwappableSlot Parms{};

	Parms.InSlot = InSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryBioDetails.GetSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxSelectable*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSelectable* UInventoryBioDetails::GetSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryBioDetails", "GetSelected");

	Params::InventoryBioDetails_GetSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryDecryptProcess.ShowDecryptProcess
// (Native, Event, Public, BlueprintEvent)

void UInventoryDecryptProcess::ShowDecryptProcess()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryDecryptProcess", "ShowDecryptProcess");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleActionDenied
// (Native, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleActionDenied(const struct FItemData& ItemData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleActionDenied");

	Params::InventoryFrame_HandleActionDenied Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleActivePanelOnEdge
// (Final, Native, Private)
// Parameters:
// class UInventorySlot*                   InSlot                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleActivePanelOnEdge(class UInventorySlot* InSlot, EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleActivePanelOnEdge");

	Params::InventoryFrame_HandleActivePanelOnEdge Parms{};

	Parms.InSlot = InSlot;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleDetailsFocused
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bFocused                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleDetailsFocused(bool bFocused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleDetailsFocused");

	Params::InventoryFrame_HandleDetailsFocused Parms{};

	Parms.bFocused = bFocused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleFaceBottomHold
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UInventorySlot*                   InSlot                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleFaceBottomHold(class UInventorySlot* InSlot, float Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleFaceBottomHold");

	Params::InventoryFrame_HandleFaceBottomHold Parms{};

	Parms.InSlot = InSlot;
	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleFaceTopHold
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UInventorySlot*                   InSlot                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleFaceTopHold(class UInventorySlot* InSlot, float Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleFaceTopHold");

	Params::InventoryFrame_HandleFaceTopHold Parms{};

	Parms.InSlot = InSlot;
	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleItemConsumed
// (Native, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleItemConsumed(const struct FItemData& ItemData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleItemConsumed");

	Params::InventoryFrame_HandleItemConsumed Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleItemDropped
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleItemDropped(const struct FItemData& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleItemDropped");

	Params::InventoryFrame_HandleItemDropped Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandlePanelNavigation
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UInventorySlot*                   InSlot                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFrame::HandlePanelNavigation(class UInventorySlot* InSlot, EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandlePanelNavigation");

	Params::InventoryFrame_HandlePanelNavigation Parms{};

	Parms.InSlot = InSlot;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleTabChanged
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleTabChanged(int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleTabChanged");

	Params::InventoryFrame_HandleTabChanged Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.HandleViewItem
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UInventoryFrame::HandleViewItem(const struct FItemData& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "HandleViewItem");

	Params::InventoryFrame_HandleViewItem Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.OnInventoryChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// const class FName&                      ItemModified                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInventoryFrame::OnInventoryChanged(const class FName& ItemModified, int32 Quantity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "OnInventoryChanged");

	Params::InventoryFrame_OnInventoryChanged Parms{};

	Parms.ItemModified = ItemModified;
	Parms.Quantity = Quantity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryFrame.GetActivePanel
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInventoryPanel*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventoryPanel* UInventoryFrame::GetActivePanel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryFrame", "GetActivePanel");

	Params::InventoryFrame_GetActivePanel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.AmmoSlot.GetNumStacks
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAmmoSlot::GetNumStacks() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AmmoSlot", "GetNumStacks");

	Params::AmmoSlot_GetNumStacks Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.InventoryTutorialPanel.OnTutorialWidgetIsFinished
// (Final, Native, Private)

void UInventoryTutorialPanel::OnTutorialWidgetIsFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryTutorialPanel", "OnTutorialWidgetIsFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.InventoryTutorialPanel.OnTutorialWidgetLoaded
// (Final, Native, Private)

void UInventoryTutorialPanel::OnTutorialWidgetLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InventoryTutorialPanel", "OnTutorialWidgetLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.ItemAmmoBox.GetAmmoAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AItemAmmoBox::GetAmmoAmount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ItemAmmoBox", "GetAmmoAmount");

	Params::ItemAmmoBox_GetAmmoAmount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ItemAmmoBox.GetAmmoWeaponType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class APhxRangedWeapon>     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class APhxRangedWeapon> AItemAmmoBox::GetAmmoWeaponType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ItemAmmoBox", "GetAmmoWeaponType");

	Params::ItemAmmoBox_GetAmmoWeaponType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Keypad.CompareInputWithPassword
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKeypad::CompareInputWithPassword()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "CompareInputWithPassword");

	Params::Keypad_CompareInputWithPassword Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Keypad.ExitKeypad
// (Final, Native, Public, BlueprintCallable)

void AKeypad::ExitKeypad()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "ExitKeypad");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.HideUI
// (Final, Native, Public, BlueprintCallable)

void AKeypad::HideUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "HideUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.MoveKeyIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Spaces                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeypad::MoveKeyIndex(int32 Spaces)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "MoveKeyIndex");

	Params::Keypad_MoveKeyIndex Parms{};

	Parms.Spaces = Spaces;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.OnPlayerInteract
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractingCharacter                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeypad::OnPlayerInteract(class APhxCharacter* InteractingCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "OnPlayerInteract");

	Params::Keypad_OnPlayerInteract Parms{};

	Parms.InteractingCharacter = InteractingCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.PushCurrentKey
// (Final, Native, Public, BlueprintCallable)

void AKeypad::PushCurrentKey()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "PushCurrentKey");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.ResetUserInput
// (Final, Native, Public, BlueprintCallable)

void AKeypad::ResetUserInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "ResetUserInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.ShowUI
// (Final, Native, Public, BlueprintCallable)

void AKeypad::ShowUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "ShowUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.StartKeypad
// (Final, Native, Public, BlueprintCallable)

void AKeypad::StartKeypad()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "StartKeypad");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.Keypad.GetCancelPressed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKeypad::GetCancelPressed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "GetCancelPressed");

	Params::Keypad_GetCancelPressed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Keypad.GetConfirmPressed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKeypad::GetConfirmPressed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "GetConfirmPressed");

	Params::Keypad_GetConfirmPressed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Keypad.GetCurrentKeyIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKeypad::GetCurrentKeyIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "GetCurrentKeyIndex");

	Params::Keypad_GetCurrentKeyIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Keypad.GetLeftPressed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKeypad::GetLeftPressed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "GetLeftPressed");

	Params::Keypad_GetLeftPressed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Keypad.GetRightPressed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKeypad::GetRightPressed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "GetRightPressed");

	Params::Keypad_GetRightPressed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.Keypad.ShouldCheckInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKeypad::ShouldCheckInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Keypad", "ShouldCheckInput");

	Params::Keypad_ShouldCheckInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGunWeapon.BP_OnShootOnReleaseCancelled
// (Event, Public, BlueprintEvent)

void APhxGunWeapon::BP_OnShootOnReleaseCancelled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGunWeapon", "BP_OnShootOnReleaseCancelled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGunWeapon.BP_OnShootOnReleaseExecuted
// (Event, Public, BlueprintEvent)

void APhxGunWeapon::BP_OnShootOnReleaseExecuted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGunWeapon", "BP_OnShootOnReleaseExecuted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGunWeapon.BP_OnShootOnReleaseInitiated
// (Event, Public, BlueprintEvent)

void APhxGunWeapon::BP_OnShootOnReleaseInitiated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGunWeapon", "BP_OnShootOnReleaseInitiated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGunWeapon.OnFireShot
// (Event, Protected, BlueprintEvent)

void APhxGunWeapon::OnFireShot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGunWeapon", "OnFireShot");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGunWeapon.SetupShootOnRelease
// (Final, Native, Protected)

void APhxGunWeapon::SetupShootOnRelease()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGunWeapon", "SetupShootOnRelease");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_UsePointOfInterest.UsePointOfInterest
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIPointOfInterest*            PointOfInterest                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_UsePointOfInterest*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_UsePointOfInterest* UPhxAIBlueprintAction_UsePointOfInterest::UsePointOfInterest(class APhxAICharacter* Character, class APhxAIPointOfInterest* PointOfInterest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_UsePointOfInterest", "UsePointOfInterest");

	Params::PhxAIBlueprintAction_UsePointOfInterest_UsePointOfInterest Parms{};

	Parms.Character = Character;
	Parms.PointOfInterest = PointOfInterest;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_UsePointOfInterest.HandlePointOfInterestDeparted
// (Final, Native, Private)
// Parameters:
// class APhxAICharacter*                  Occupier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIPointOfInterest*            PointOfInterest                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_UsePointOfInterest::HandlePointOfInterestDeparted(class APhxAICharacter* Occupier, class APhxAIPointOfInterest* PointOfInterest, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_UsePointOfInterest", "HandlePointOfInterestDeparted");

	Params::PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestDeparted Parms{};

	Parms.Occupier = Occupier;
	Parms.PointOfInterest = PointOfInterest;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_UsePointOfInterest.HandlePointOfInterestReached
// (Final, Native, Private)
// Parameters:
// class APhxAICharacter*                  Occupier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIPointOfInterest*            PointOfInterest                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_UsePointOfInterest::HandlePointOfInterestReached(class APhxAICharacter* Occupier, class APhxAIPointOfInterest* PointOfInterest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_UsePointOfInterest", "HandlePointOfInterestReached");

	Params::PhxAIBlueprintAction_UsePointOfInterest_HandlePointOfInterestReached Parms{};

	Parms.Occupier = Occupier;
	Parms.PointOfInterest = PointOfInterest;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.LevelSelectWidget.GenerateMenu
// (Final, Native, Public, BlueprintCallable)

void ULevelSelectWidget::GenerateMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LevelSelectWidget", "GenerateMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.LevelSelectWidget.GetFirstButton
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMenuButton*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMenuButton* ULevelSelectWidget::GetFirstButton()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LevelSelectWidget", "GetFirstButton");

	Params::LevelSelectWidget_GetFirstButton Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.LevelButtonProxy.LoadLevel
// (Final, Native, Public)

void ULevelButtonProxy::LoadLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LevelButtonProxy", "LoadLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.LoadingState.OnEndFakeLoad
// (Final, Native, Protected)

void ULoadingState::OnEndFakeLoad()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LoadingState", "OnEndFakeLoad");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterBase.PlayDialogue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InDialogue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacterBase::PlayDialogue(class UDialogue* InDialogue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterBase", "PlayDialogue");

	Params::PhxCharacterBase_PlayDialogue Parms{};

	Parms.InDialogue = InDialogue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterBase.StartRagdoll
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacterBase::StartRagdoll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterBase", "StartRagdoll");

	Params::PhxCharacterBase_StartRagdoll Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterBase.StopRagdoll
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bReenableMovement                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacterBase::StopRagdoll(bool bReenableMovement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterBase", "StopRagdoll");

	Params::PhxCharacterBase_StopRagdoll Parms{};

	Parms.bReenableMovement = bReenableMovement;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.AlignCapsuleToRagdoll
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::AlignCapsuleToRagdoll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "AlignCapsuleToRagdoll");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.ClearPoseSnapshot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   BlendOutTime                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::ClearPoseSnapshot(float BlendOutTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ClearPoseSnapshot");

	Params::PhxCharacter_ClearPoseSnapshot Parms{};

	Parms.BlendOutTime = BlendOutTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.EndPhysics
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      BodyName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      ProfileName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludeSelf                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendOutTime                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::EndPhysics(const class FName& BodyName, const class FName& ProfileName, bool bIncludeSelf, float BlendOutTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "EndPhysics");

	Params::PhxCharacter_EndPhysics Parms{};

	Parms.BodyName = BodyName;
	Parms.ProfileName = ProfileName;
	Parms.bIncludeSelf = bIncludeSelf;
	Parms.BlendOutTime = BlendOutTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.EnterTaggedTriggerVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TriggerActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::EnterTaggedTriggerVolume(class AActor* TriggerActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "EnterTaggedTriggerVolume");

	Params::PhxCharacter_EnterTaggedTriggerVolume Parms{};

	Parms.TriggerActor = TriggerActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.ExitTaggedTriggerVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TriggerActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::ExitTaggedTriggerVolume(class AActor* TriggerActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ExitTaggedTriggerVolume");

	Params::PhxCharacter_ExitTaggedTriggerVolume Parms{};

	Parms.TriggerActor = TriggerActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.GetAllEquipment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class AEquippable*>        ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class AEquippable*> APhxCharacter::GetAllEquipment()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetAllEquipment");

	Params::PhxCharacter_GetAllEquipment Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.HandleOnHealthChanged
// (Final, Native, Protected)
// Parameters:
// class UPhxHealthComponent*              CallingHealthComp                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::HandleOnHealthChanged(class UPhxHealthComponent* CallingHealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "HandleOnHealthChanged");

	Params::PhxCharacter_HandleOnHealthChanged Parms{};

	Parms.CallingHealthComp = CallingHealthComp;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.IsOnCamera
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsOnCamera()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsOnCamera");

	Params::PhxCharacter_IsOnCamera Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsPhysicsActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsPhysicsActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsPhysicsActive");

	Params::PhxCharacter_IsPhysicsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.Kill
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UDamageType>          DamageType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::Kill(class AActor* DamageCauser, TSubclassOf<class UDamageType> DamageType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "Kill");

	Params::PhxCharacter_Kill Parms{};

	Parms.DamageCauser = DamageCauser;
	Parms.DamageType = DamageType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.LockCombatActions
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::LockCombatActions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "LockCombatActions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.MakeInvulnerableForScareGag
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::MakeInvulnerableForScareGag()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "MakeInvulnerableForScareGag");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.MakeVulnerableForScareGag
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::MakeVulnerableForScareGag()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "MakeVulnerableForScareGag");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.NotifyPostDeathEnd
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::NotifyPostDeathEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "NotifyPostDeathEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.OnBeginOverlap
// (Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxCharacter::OnBeginOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnBeginOverlap");

	Params::PhxCharacter_OnBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.OnBodyPartDead
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const TArray<EPhxBodyPartType>&         KilledParts                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           InstigatorActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OwningCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::OnBodyPartDead(const TArray<EPhxBodyPartType>& KilledParts, class AActor* InstigatorActor, class AActor* OwningCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnBodyPartDead");

	Params::PhxCharacter_OnBodyPartDead Parms{};

	Parms.KilledParts = std::move(KilledParts);
	Parms.InstigatorActor = InstigatorActor;
	Parms.OwningCharacter = OwningCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.OnDisabledFootIK
// (Event, Public, BlueprintEvent)

void APhxCharacter::OnDisabledFootIK()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnDisabledFootIK");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxCharacter.OnEnabledFootIK
// (Event, Public, BlueprintEvent)

void APhxCharacter::OnEnabledFootIK()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnEnabledFootIK");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxCharacter.OnEndOverlap
// (Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::OnEndOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnEndOverlap");

	Params::PhxCharacter_OnEndOverlap Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.OnKilledByVentBot
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::OnKilledByVentBot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnKilledByVentBot");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.OnLandedReceived
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnLandedReceived");

	Params::PhxCharacter_OnLandedReceived Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.OnTagUpdated
// (Final, Native, Public)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bExist                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::OnTagUpdated(const struct FGameplayTag& Tag, bool bExist)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "OnTagUpdated");

	Params::PhxCharacter_OnTagUpdated Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.PopScriptLock
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::PopScriptLock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "PopScriptLock");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.PushScriptLock
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::PushScriptLock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "PushScriptLock");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.ReactToWeaponBreak
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEquippable*                      Equipment                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::ReactToWeaponBreak(class AEquippable* Equipment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ReactToWeaponBreak");

	Params::PhxCharacter_ReactToWeaponBreak Parms{};

	Parms.Equipment = Equipment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.RequestActionAbort
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bPlayerRequested                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::RequestActionAbort(bool bPlayerRequested)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "RequestActionAbort");

	Params::PhxCharacter_RequestActionAbort Parms{};

	Parms.bPlayerRequested = bPlayerRequested;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.RequestMovementSplineStateEnter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPhxMovementSplineStateRequest&InRequest                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxCharacter::RequestMovementSplineStateEnter(const struct FPhxMovementSplineStateRequest& InRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "RequestMovementSplineStateEnter");

	Params::PhxCharacter_RequestMovementSplineStateEnter Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.RequestMovementSplineStateExit
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::RequestMovementSplineStateExit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "RequestMovementSplineStateExit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.RequestRagdollSleep
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::RequestRagdollSleep()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "RequestRagdollSleep");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.RequestSnowcatOccupantState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxSnowcatSpline*                InSnowcatSpline                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  InAttachComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         LocationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         RotationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::RequestSnowcatOccupantState(class APhxSnowcatSpline* InSnowcatSpline, class USceneComponent* InAttachComponent, EAttachmentRule LocationRule, EAttachmentRule RotationRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "RequestSnowcatOccupantState");

	Params::PhxCharacter_RequestSnowcatOccupantState Parms{};

	Parms.InSnowcatSpline = InSnowcatSpline;
	Parms.InAttachComponent = InAttachComponent;
	Parms.LocationRule = LocationRule;
	Parms.RotationRule = RotationRule;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SaveAndUsePoseSnapshot
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::SaveAndUsePoseSnapshot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SaveAndUsePoseSnapshot");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SetAimRequest
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bSet                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::SetAimRequest(bool bSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SetAimRequest");

	Params::PhxCharacter_SetAimRequest Parms{};

	Parms.bSet = bSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SetCanPerformMeleeAttack
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bCanMelee                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::SetCanPerformMeleeAttack(bool bCanMelee)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SetCanPerformMeleeAttack");

	Params::PhxCharacter_SetCanPerformMeleeAttack Parms{};

	Parms.bCanMelee = bCanMelee;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SetCanShoot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bCanShoot                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::SetCanShoot(bool bCanShoot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SetCanShoot");

	Params::PhxCharacter_SetCanShoot Parms{};

	Parms.bCanShoot = bCanShoot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SetForceInBreathableEnvironment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bForceBreathable                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::SetForceInBreathableEnvironment(bool bForceBreathable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SetForceInBreathableEnvironment");

	Params::PhxCharacter_SetForceInBreathableEnvironment Parms{};

	Parms.bForceBreathable = bForceBreathable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SetIsPrevizVideoPlaying
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bVideoPlaying                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::SetIsPrevizVideoPlaying(bool bVideoPlaying)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SetIsPrevizVideoPlaying");

	Params::PhxCharacter_SetIsPrevizVideoPlaying Parms{};

	Parms.bVideoPlaying = bVideoPlaying;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SetReload
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bReload                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::SetReload(bool bReload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SetReload");

	Params::PhxCharacter_SetReload Parms{};

	Parms.bReload = bReload;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.SetStompLocked
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bLocked                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::SetStompLocked(bool bLocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "SetStompLocked");

	Params::PhxCharacter_SetStompLocked Parms{};

	Parms.bLocked = bLocked;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.ShouldEnableClothSim
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::ShouldEnableClothSim()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ShouldEnableClothSim");

	Params::PhxCharacter_ShouldEnableClothSim Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.StartBreathing
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::StartBreathing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "StartBreathing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.StartPhysics
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      BodyName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      ProfileName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      ConstraintProfileName                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludeSelf                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendInTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECharacterPhysicsBlendType              Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::StartPhysics(const class FName& BodyName, const class FName& ProfileName, const class FName& ConstraintProfileName, bool bIncludeSelf, float BlendInTime, ECharacterPhysicsBlendType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "StartPhysics");

	Params::PhxCharacter_StartPhysics Parms{};

	Parms.BodyName = BodyName;
	Parms.ProfileName = ProfileName;
	Parms.ConstraintProfileName = ConstraintProfileName;
	Parms.bIncludeSelf = bIncludeSelf;
	Parms.BlendInTime = BlendInTime;
	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.StopBreathing
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::StopBreathing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "StopBreathing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.UnlockCombatActions
// (Final, Native, Public, BlueprintCallable)

void APhxCharacter::UnlockCombatActions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "UnlockCombatActions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.UpdatePropKickerComponentSize
// (Final, Native, Protected)

void APhxCharacter::UpdatePropKickerComponentSize()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "UpdatePropKickerComponentSize");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.CanPerformMeleeAttack
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const bool APhxCharacter::CanPerformMeleeAttack() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "CanPerformMeleeAttack");

	Params::PhxCharacter_CanPerformMeleeAttack Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.CanShoot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const bool APhxCharacter::CanShoot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "CanShoot");

	Params::PhxCharacter_CanShoot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.DoesBoneExists
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName&                      BoneName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::DoesBoneExists(const class FName& BoneName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "DoesBoneExists");

	Params::PhxCharacter_DoesBoneExists Parms{};

	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetBodyMesh
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* APhxCharacter::GetBodyMesh() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetBodyMesh");

	Params::PhxCharacter_GetBodyMesh Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetBodySkeletalMeshComponent
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* APhxCharacter::GetBodySkeletalMeshComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetBodySkeletalMeshComponent");

	Params::PhxCharacter_GetBodySkeletalMeshComponent Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetBoneLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName&                      BoneName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RelativeOffset                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxCharacter::GetBoneLocation(const class FName& BoneName, const struct FVector& RelativeOffset) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetBoneLocation");

	Params::PhxCharacter_GetBoneLocation Parms{};

	Parms.BoneName = BoneName;
	Parms.RelativeOffset = std::move(RelativeOffset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetCameraActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ACameraActor*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ACameraActor* APhxCharacter::GetCameraActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetCameraActor");

	Params::PhxCharacter_GetCameraActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetCameraRig
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCameraRig*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCameraRig* APhxCharacter::GetCameraRig() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetCameraRig");

	Params::PhxCharacter_GetCameraRig Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetCapsuleBottom
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   RelativeOffset                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxCharacter::GetCapsuleBottom(const struct FVector& RelativeOffset) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetCapsuleBottom");

	Params::PhxCharacter_GetCapsuleBottom Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetCapsuleTop
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   RelativeOffset                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxCharacter::GetCapsuleTop(const struct FVector& RelativeOffset) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetCapsuleTop");

	Params::PhxCharacter_GetCapsuleTop Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetCharacterDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxCharacterDefinition*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCharacterDefinition* APhxCharacter::GetCharacterDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetCharacterDefinition");

	Params::PhxCharacter_GetCharacterDefinition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetCharacterTag
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayTag APhxCharacter::GetCharacterTag() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetCharacterTag");

	Params::PhxCharacter_GetCharacterTag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetClothSimMeshes
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// TArray<class USkeletalMeshComponent*>   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class USkeletalMeshComponent*> APhxCharacter::GetClothSimMeshes() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetClothSimMeshes");

	Params::PhxCharacter_GetClothSimMeshes Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetDesiredMoveDirection
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    AllowZero                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxCharacter::GetDesiredMoveDirection(bool AllowZero) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetDesiredMoveDirection");

	Params::PhxCharacter_GetDesiredMoveDirection Parms{};

	Parms.AllowZero = AllowZero;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetEquipmentAttachParent
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* APhxCharacter::GetEquipmentAttachParent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetEquipmentAttachParent");

	Params::PhxCharacter_GetEquipmentAttachParent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEquippable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEquippable* APhxCharacter::GetEquipped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetEquipped");

	Params::PhxCharacter_GetEquipped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetFlashlightComponent
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UPhxFlashlightComponent*          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxFlashlightComponent* APhxCharacter::GetFlashlightComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetFlashlightComponent");

	Params::PhxCharacter_GetFlashlightComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetFloorLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   RelativeOffset                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxCharacter::GetFloorLocation(const struct FVector& RelativeOffset) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetFloorLocation");

	Params::PhxCharacter_GetFloorLocation Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetFootfallVFX
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhysicalSurface                        SurfaceType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraSystem*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNiagaraSystem* APhxCharacter::GetFootfallVFX(EPhysicalSurface SurfaceType, float Speed) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetFootfallVFX");

	Params::PhxCharacter_GetFootfallVFX Parms{};

	Parms.SurfaceType = SurfaceType;
	Parms.Speed = Speed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetForceHeadTrackingLookAtLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxCharacter::GetForceHeadTrackingLookAtLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetForceHeadTrackingLookAtLocation");

	Params::PhxCharacter_GetForceHeadTrackingLookAtLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetHasTargetToLookAt
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::GetHasTargetToLookAt() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetHasTargetToLookAt");

	Params::PhxCharacter_GetHasTargetToLookAt Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetHealthPercentage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxCharacter::GetHealthPercentage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetHealthPercentage");

	Params::PhxCharacter_GetHealthPercentage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetInteractionComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxCharacterInteractionComponent*ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCharacterInteractionComponent* APhxCharacter::GetInteractionComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetInteractionComponent");

	Params::PhxCharacter_GetInteractionComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetIsAiming
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::GetIsAiming() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetIsAiming");

	Params::PhxCharacter_GetIsAiming Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetMeshBoneData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMeshBoneData*                   BoneData                                               (Parm, OutParm, ContainsInstancedReference, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::GetMeshBoneData(class FName BoneName, struct FMeshBoneData* BoneData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetMeshBoneData");

	Params::PhxCharacter_GetMeshBoneData Parms{};

	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetPlayerController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxPlayerController*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxPlayerController* APhxCharacter::GetPlayerController() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetPlayerController");

	Params::PhxCharacter_GetPlayerController Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.GetStance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECharacterStance                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECharacterStance APhxCharacter::GetStance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "GetStance");

	Params::PhxCharacter_GetStance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsCharacterCrouched
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsCharacterCrouched() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsCharacterCrouched");

	Params::PhxCharacter_IsCharacterCrouched Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsCharacterInState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UState>               StateClass                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsCharacterInState(TSubclassOf<class UState> StateClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsCharacterInState");

	Params::PhxCharacter_IsCharacterInState Parms{};

	Parms.StateClass = StateClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsCharacterInStateId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsCharacterInStateId(class FName ID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsCharacterInStateId");

	Params::PhxCharacter_IsCharacterInStateId Parms{};

	Parms.ID = ID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsControlledByAdHocCinematic
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsControlledByAdHocCinematic() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsControlledByAdHocCinematic");

	Params::PhxCharacter_IsControlledByAdHocCinematic Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsControlledByScriptedEvent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsControlledByScriptedEvent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsControlledByScriptedEvent");

	Params::PhxCharacter_IsControlledByScriptedEvent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsDead
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

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

	Params::PhxCharacter_IsDead Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsInTaggedTriggerVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             TagName                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsInTaggedTriggerVolume(class FName TagName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsInTaggedTriggerVolume");

	Params::PhxCharacter_IsInTaggedTriggerVolume Parms{};

	Parms.TagName = TagName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsInvulnerableTo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    Attacker                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsInvulnerableTo(class APhxCharacter* Attacker) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsInvulnerableTo");

	Params::PhxCharacter_IsInvulnerableTo Parms{};

	Parms.Attacker = Attacker;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsUngrabbableBy
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    Attacker                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsUngrabbableBy(class APhxCharacter* Attacker) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsUngrabbableBy");

	Params::PhxCharacter_IsUngrabbableBy Parms{};

	Parms.Attacker = Attacker;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.IsUninterruptibleBy
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    Attacker                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           DamageTypeClass                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::IsUninterruptibleBy(class APhxCharacter* Attacker, class UClass* DamageTypeClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "IsUninterruptibleBy");

	Params::PhxCharacter_IsUninterruptibleBy Parms{};

	Parms.Attacker = Attacker;
	Parms.DamageTypeClass = DamageTypeClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.LockOutActions
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::LockOutActions() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "LockOutActions");

	Params::PhxCharacter_LockOutActions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.LockOutCorpseStomp
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::LockOutCorpseStomp() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "LockOutCorpseStomp");

	Params::PhxCharacter_LockOutCorpseStomp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.LockOutEquipment
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::LockOutEquipment() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "LockOutEquipment");

	Params::PhxCharacter_LockOutEquipment Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.LockOutInteractions
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::LockOutInteractions() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "LockOutInteractions");

	Params::PhxCharacter_LockOutInteractions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.LockOutMovement
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::LockOutMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "LockOutMovement");

	Params::PhxCharacter_LockOutMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.ReplaceMeshUserDataDefinition
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UPhxMeshUserDataDefinition*       PhxMeshUserDataDefinition                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCharacter::ReplaceMeshUserDataDefinition(class UPhxMeshUserDataDefinition* PhxMeshUserDataDefinition) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ReplaceMeshUserDataDefinition");

	Params::PhxCharacter_ReplaceMeshUserDataDefinition Parms{};

	Parms.PhxMeshUserDataDefinition = PhxMeshUserDataDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacter.ShouldForceHeadtracking
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::ShouldForceHeadtracking() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ShouldForceHeadtracking");

	Params::PhxCharacter_ShouldForceHeadtracking Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.ShouldPlayEnvironmentalAnim
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::ShouldPlayEnvironmentalAnim() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ShouldPlayEnvironmentalAnim");

	Params::PhxCharacter_ShouldPlayEnvironmentalAnim Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.ShouldUseFlashlightWhenHeadTracking
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::ShouldUseFlashlightWhenHeadTracking() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "ShouldUseFlashlightWhenHeadTracking");

	Params::PhxCharacter_ShouldUseFlashlightWhenHeadTracking Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacter.UsingFlashlight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCharacter::UsingFlashlight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacter", "UsingFlashlight");

	Params::PhxCharacter_UsingFlashlight Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacter.DynamicDropsItemDroppedChanged
// (Final, Native, Public)
// Parameters:
// bool                                    bItemDropped                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICharacter::DynamicDropsItemDroppedChanged(bool bItemDropped)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "DynamicDropsItemDroppedChanged");

	Params::PhxAICharacter_DynamicDropsItemDroppedChanged Parms{};

	Parms.bItemDropped = bItemDropped;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacter.NotifyShotFired
// (Final, Native, Public)

void APhxAICharacter::NotifyShotFired()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "NotifyShotFired");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacter.OnEnterGRPHeld
// (Event, Public, BlueprintEvent)

void APhxAICharacter::OnEnterGRPHeld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OnEnterGRPHeld");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAICharacter.OnEnterGRPLaunched
// (Event, Public, BlueprintEvent)

void APhxAICharacter::OnEnterGRPLaunched()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OnEnterGRPLaunched");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAICharacter.OnEnterGRPPulled
// (Event, Public, BlueprintEvent)

void APhxAICharacter::OnEnterGRPPulled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OnEnterGRPPulled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAICharacter.OnGRPCollidedDuringHeld
// (Event, Public, BlueprintEvent)

void APhxAICharacter::OnGRPCollidedDuringHeld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OnGRPCollidedDuringHeld");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAICharacter.OnGRPCollidedDuringLaunched
// (Event, Public, BlueprintEvent)
// Parameters:
// EPhxGRPLaunchCollisionHitType           LaunchCollisionHitType                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICharacter::OnGRPCollidedDuringLaunched(EPhxGRPLaunchCollisionHitType LaunchCollisionHitType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OnGRPCollidedDuringLaunched");

	Params::PhxAICharacter_OnGRPCollidedDuringLaunched Parms{};

	Parms.LaunchCollisionHitType = LaunchCollisionHitType;

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


// Function Phoenix.PhxAICharacter.OnGRPCollidedDuringPulled
// (Event, Public, BlueprintEvent)

void APhxAICharacter::OnGRPCollidedDuringPulled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OnGRPCollidedDuringPulled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAICharacter.OnGRPRelease
// (Event, Public, BlueprintEvent)

void APhxAICharacter::OnGRPRelease()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OnGRPRelease");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAICharacter.OverrideSelectedTarget_DebugOnly
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICharacter::OverrideSelectedTarget_DebugOnly(class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "OverrideSelectedTarget_DebugOnly");

	Params::PhxAICharacter_OverrideSelectedTarget_DebugOnly Parms{};

	Parms.TargetActor = TargetActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacter.GeHighContrastMenuAnimSequence
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class UAnimSequence*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequence* APhxAICharacter::GeHighContrastMenuAnimSequence() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "GeHighContrastMenuAnimSequence");

	Params::PhxAICharacter_GeHighContrastMenuAnimSequence Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacter.GetAdditionalHighContrastMenuMeshes
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// TArray<class USkeletalMesh*>*           OutSkelMeshes                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void APhxAICharacter::GetAdditionalHighContrastMenuMeshes(TArray<class USkeletalMesh*>* OutSkelMeshes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "GetAdditionalHighContrastMenuMeshes");

	Params::PhxAICharacter_GetAdditionalHighContrastMenuMeshes Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function Phoenix.PhxAICharacter.GetCharacterComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxAICharacterComponent*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAICharacterComponent* APhxAICharacter::GetCharacterComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "GetCharacterComponent");

	Params::PhxAICharacter_GetCharacterComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacter.GetDefensiveActionsComponent
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxAIDefensiveActionsComponent*  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIDefensiveActionsComponent* APhxAICharacter::GetDefensiveActionsComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "GetDefensiveActionsComponent");

	Params::PhxAICharacter_GetDefensiveActionsComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacter.GetNumPPEChargesApplied
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxAICharacter::GetNumPPEChargesApplied() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "GetNumPPEChargesApplied");

	Params::PhxAICharacter_GetNumPPEChargesApplied Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacter.GetOffensiveActionsComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxAIOffensiveActionsComponent*  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIOffensiveActionsComponent* APhxAICharacter::GetOffensiveActionsComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacter", "GetOffensiveActionsComponent");

	Params::PhxAICharacter_GetOffensiveActionsComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.ActivateCameraState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const struct FCameraGraphEntrySelector& TargetCamera                                           (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::ActivateCameraState(const struct FCameraGraphEntrySelector& TargetCamera, bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "ActivateCameraState");

	Params::PhxGameplayStatics_ActivateCameraState Parms{};

	Parms.TargetCamera = std::move(TargetCamera);
	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.AddStreamingViewSlaveLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   SlaveLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BoostFactor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOverrideLocation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::AddStreamingViewSlaveLocation(const struct FVector& SlaveLocation, float BoostFactor, bool bOverrideLocation, float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "AddStreamingViewSlaveLocation");

	Params::PhxGameplayStatics_AddStreamingViewSlaveLocation Parms{};

	Parms.SlaveLocation = std::move(SlaveLocation);
	Parms.BoostFactor = BoostFactor;
	Parms.bOverrideLocation = bOverrideLocation;
	Parms.Duration = Duration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.CheckCapsuleToCapsuleCollision
// (Final, Native, Static, Public, HasDefaults)
// Parameters:
// const struct FVector&                   CapsuleALocation                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CapsuleARadius                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CapsuleAHalfHeight                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CapsuleAUpVector                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CapsuleBLocation                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CapsuleBRadius                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CapsuleBHalfHeight                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CapsuleBUpVector                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::CheckCapsuleToCapsuleCollision(const struct FVector& CapsuleALocation, float CapsuleARadius, float CapsuleAHalfHeight, const struct FVector& CapsuleAUpVector, const struct FVector& CapsuleBLocation, float CapsuleBRadius, float CapsuleBHalfHeight, const struct FVector& CapsuleBUpVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "CheckCapsuleToCapsuleCollision");

	Params::PhxGameplayStatics_CheckCapsuleToCapsuleCollision Parms{};

	Parms.CapsuleALocation = std::move(CapsuleALocation);
	Parms.CapsuleARadius = CapsuleARadius;
	Parms.CapsuleAHalfHeight = CapsuleAHalfHeight;
	Parms.CapsuleAUpVector = std::move(CapsuleAUpVector);
	Parms.CapsuleBLocation = std::move(CapsuleBLocation);
	Parms.CapsuleBRadius = CapsuleBRadius;
	Parms.CapsuleBHalfHeight = CapsuleBHalfHeight;
	Parms.CapsuleBUpVector = std::move(CapsuleBUpVector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.ClearEntitlementCache
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   UserNum                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::ClearEntitlementCache(int32 UserNum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "ClearEntitlementCache");

	Params::PhxGameplayStatics_ClearEntitlementCache Parms{};

	Parms.UserNum = UserNum;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.ConvertMayaRotationToUnrealSpace
// (Final, Native, Static, Public, HasDefaults)
// Parameters:
// const struct FRotator&                  MayaRot                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UPhxGameplayStatics::ConvertMayaRotationToUnrealSpace(const struct FRotator& MayaRot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "ConvertMayaRotationToUnrealSpace");

	Params::PhxGameplayStatics_ConvertMayaRotationToUnrealSpace Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.ExecuteGameplayCondition
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPhxGameplayConditionContainer&ConditionContainer                                     (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FGameplayConditionContext& ConditionContext                                       (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::ExecuteGameplayCondition(const struct FPhxGameplayConditionContainer& ConditionContainer, const struct FGameplayConditionContext& ConditionContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "ExecuteGameplayCondition");

	Params::PhxGameplayStatics_ExecuteGameplayCondition Parms{};

	Parms.ConditionContainer = std::move(ConditionContainer);
	Parms.ConditionContext = std::move(ConditionContext);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.ForcePlayerOntoTraversalSpline
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxPlayerCharacter*              InPlayerCharacter                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxTraversalSpline*              InTraversalSpline                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::ForcePlayerOntoTraversalSpline(class APhxPlayerCharacter* InPlayerCharacter, class APhxTraversalSpline* InTraversalSpline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "ForcePlayerOntoTraversalSpline");

	Params::PhxGameplayStatics_ForcePlayerOntoTraversalSpline Parms{};

	Parms.InPlayerCharacter = InPlayerCharacter;
	Parms.InTraversalSpline = InTraversalSpline;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.GetAnimCurveValueAtTime
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAnimSequenceBase*                Sequence                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           SkelMesh                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             CurveName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutCurveValue                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::GetAnimCurveValueAtTime(class UAnimSequenceBase* Sequence, class USkeletalMeshComponent* SkelMesh, class FName CurveName, float Time, float* OutCurveValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetAnimCurveValueAtTime");

	Params::PhxGameplayStatics_GetAnimCurveValueAtTime Parms{};

	Parms.Sequence = Sequence;
	Parms.SkelMesh = SkelMesh;
	Parms.CurveName = CurveName;
	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetAnimMontageCurrentTime
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           SkelMesh                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutTime                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::GetAnimMontageCurrentTime(class UAnimMontage* Montage, class USkeletalMeshComponent* SkelMesh, float* OutTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetAnimMontageCurrentTime");

	Params::PhxGameplayStatics_GetAnimMontageCurrentTime Parms{};

	Parms.Montage = Montage;
	Parms.SkelMesh = SkelMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetBoneTransformFromAnimSequenceAtTime
// (Final, Native, Static, Public, HasDefaults)
// Parameters:
// class USkeletalMeshComponent*           Mesh                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequence*                    AnimSequence                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UPhxGameplayStatics::GetBoneTransformFromAnimSequenceAtTime(class USkeletalMeshComponent* Mesh, class UAnimSequence* AnimSequence, class FName BoneName, float Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetBoneTransformFromAnimSequenceAtTime");

	Params::PhxGameplayStatics_GetBoneTransformFromAnimSequenceAtTime Parms{};

	Parms.Mesh = Mesh;
	Parms.AnimSequence = AnimSequence;
	Parms.BoneName = BoneName;
	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetBoneTransformFromMontageAtTime
// (Final, Native, Static, Public, HasDefaults)
// Parameters:
// class USkeletalMeshComponent*           Mesh                                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   AnimSegmentIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UPhxGameplayStatics::GetBoneTransformFromMontageAtTime(class USkeletalMeshComponent* Mesh, class UAnimMontage* AnimMontage, class FName BoneName, float Time, int32 AnimSegmentIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetBoneTransformFromMontageAtTime");

	Params::PhxGameplayStatics_GetBoneTransformFromMontageAtTime Parms{};

	Parms.Mesh = Mesh;
	Parms.AnimMontage = AnimMontage;
	Parms.BoneName = BoneName;
	Parms.Time = Time;
	Parms.AnimSegmentIndex = AnimSegmentIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetCurrentCheckpointFromProgress
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACheckpoint*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ACheckpoint* UPhxGameplayStatics::GetCurrentCheckpointFromProgress(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetCurrentCheckpointFromProgress");

	Params::PhxGameplayStatics_GetCurrentCheckpointFromProgress Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetCurrentPrinter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APrinterV2*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APrinterV2* UPhxGameplayStatics::GetCurrentPrinter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetCurrentPrinter");

	Params::PhxGameplayStatics_GetCurrentPrinter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetLevelScriptActor
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ALevelScriptActor*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ALevelScriptActor* UPhxGameplayStatics::GetLevelScriptActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetLevelScriptActor");

	Params::PhxGameplayStatics_GetLevelScriptActor Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetPhxGameMode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhoenixGameModeBase*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhoenixGameModeBase* UPhxGameplayStatics::GetPhxGameMode(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetPhxGameMode");

	Params::PhxGameplayStatics_GetPhxGameMode Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetPhxPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PlayerIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxPlayerCharacter*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxPlayerCharacter* UPhxGameplayStatics::GetPhxPlayerCharacter(const class UObject* WorldContextObject, int32 PlayerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetPhxPlayerCharacter");

	Params::PhxGameplayStatics_GetPhxPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerIndex = PlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetPhxSoundComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  AttachToComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AttachPointName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSoundComponent*               ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSoundComponent* UPhxGameplayStatics::GetPhxSoundComponent(class USceneComponent* AttachToComponent, class FName AttachPointName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetPhxSoundComponent");

	Params::PhxGameplayStatics_GetPhxSoundComponent Parms{};

	Parms.AttachToComponent = AttachToComponent;
	Parms.AttachPointName = AttachPointName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetPlayerInventory
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxCharacterInventoryComponent*  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCharacterInventoryComponent* UPhxGameplayStatics::GetPlayerInventory(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetPlayerInventory");

	Params::PhxGameplayStatics_GetPlayerInventory Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetTerritoryReleaseSettings
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FPhxTerritoryReleaseSettingsReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FPhxTerritoryReleaseSettings UPhxGameplayStatics::GetTerritoryReleaseSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetTerritoryReleaseSettings");

	Params::PhxGameplayStatics_GetTerritoryReleaseSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetUIComponent
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxPlayerControllerUIComponent*  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxPlayerControllerUIComponent* UPhxGameplayStatics::GetUIComponent(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetUIComponent");

	Params::PhxGameplayStatics_GetUIComponent Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.GetUISystem
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USDSUISystem*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSUISystem* UPhxGameplayStatics::GetUISystem(class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "GetUISystem");

	Params::PhxGameplayStatics_GetUISystem Parms{};

	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.HasGateExecuted
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    GateId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::HasGateExecuted(class UObject* WorldContextObject, const class FString& GateId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "HasGateExecuted");

	Params::PhxGameplayStatics_HasGateExecuted Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GateId = std::move(GateId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.InstantEquipWeapon
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AWeapon>              WeaponClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShowNotification                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::InstantEquipWeapon(class APhxCharacter* Character, TSubclassOf<class AWeapon> WeaponClass, bool bShowNotification)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "InstantEquipWeapon");

	Params::PhxGameplayStatics_InstantEquipWeapon Parms{};

	Parms.Character = Character;
	Parms.WeaponClass = WeaponClass;
	Parms.bShowNotification = bShowNotification;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.IsConsole
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsConsole(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsConsole");

	Params::PhxGameplayStatics_IsConsole Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsDemoMode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsDemoMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsDemoMode");

	Params::PhxGameplayStatics_IsDemoMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsGameplayMap
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsGameplayMap(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsGameplayMap");

	Params::PhxGameplayStatics_IsGameplayMap Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsHealthBarRequired
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsHealthBarRequired(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsHealthBarRequired");

	Params::PhxGameplayStatics_IsHealthBarRequired Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsHitReactionValid
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FHitReactionData&          HitReactionData                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsHitReactionValid(const struct FHitReactionData& HitReactionData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsHitReactionValid");

	Params::PhxGameplayStatics_IsHitReactionValid Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsInMenus
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsInMenus(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsInMenus");

	Params::PhxGameplayStatics_IsInMenus Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsIntroMap
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsIntroMap(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsIntroMap");

	Params::PhxGameplayStatics_IsIntroMap Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsLocationOnScreen
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsLocationOnScreen(const class UObject* WorldContextObject, const struct FVector& WorldLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsLocationOnScreen");

	Params::PhxGameplayStatics_IsLocationOnScreen Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.WorldLocation = std::move(WorldLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsLowEndStreamingPlatform
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsLowEndStreamingPlatform()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsLowEndStreamingPlatform");

	Params::PhxGameplayStatics_IsLowEndStreamingPlatform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsMiddleEndPlatform
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsMiddleEndPlatform()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsMiddleEndPlatform");

	Params::PhxGameplayStatics_IsMiddleEndPlatform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsOnline
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsOnline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsOnline");

	Params::PhxGameplayStatics_IsOnline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsOutroMap
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsOutroMap(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsOutroMap");

	Params::PhxGameplayStatics_IsOutroMap Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsReducedGoreEnabled
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsReducedGoreEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsReducedGoreEnabled");

	Params::PhxGameplayStatics_IsReducedGoreEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsShippingBuild
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsShippingBuild()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsShippingBuild");

	Params::PhxGameplayStatics_IsShippingBuild Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.IsStoreFrontEnabled
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::IsStoreFrontEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "IsStoreFrontEnabled");

	Params::PhxGameplayStatics_IsStoreFrontEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.PhxCheckDoneForDoOnceGate
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Key                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bDone                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxDoOnceCheckDonePath*                Path                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PhxCheckDoneForDoOnceGate(class UObject* WorldContextObject, const class FString& Key, bool* bDone, EPhxDoOnceCheckDonePath* Path)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PhxCheckDoneForDoOnceGate");

	Params::PhxGameplayStatics_PhxCheckDoneForDoOnceGate Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Key = std::move(Key);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxGameplayStatics.PhxGetLevelScriptActor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const TSoftObjectPtr<class UWorld>&     SubLevel                                               (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ALevelScriptActor*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ALevelScriptActor* UPhxGameplayStatics::PhxGetLevelScriptActor(const TSoftObjectPtr<class UWorld>& SubLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PhxGetLevelScriptActor");

	Params::PhxGameplayStatics_PhxGetLevelScriptActor Parms{};

	Parms.SubLevel = SubLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.PhxLoadSharedStreamLevel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSoftObjectPtr<class UWorld>      Level                                                  (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bMakeVisibleAfterLoad                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldBlockOnLoad                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PhxLoadSharedStreamLevel(const class UObject* WorldContextObject, const TSoftObjectPtr<class UWorld> Level, bool bMakeVisibleAfterLoad, bool bShouldBlockOnLoad, const struct FLatentActionInfo& LatentInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PhxLoadSharedStreamLevel");

	Params::PhxGameplayStatics_PhxLoadSharedStreamLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Level = Level;
	Parms.bMakeVisibleAfterLoad = bMakeVisibleAfterLoad;
	Parms.bShouldBlockOnLoad = bShouldBlockOnLoad;
	Parms.LatentInfo = std::move(LatentInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PhxPlayMedia
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UMediaPlayer*                     MediaPlayer                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::PhxPlayMedia(class UMediaPlayer* MediaPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PhxPlayMedia");

	Params::PhxGameplayStatics_PhxPlayMedia Parms{};

	Parms.MediaPlayer = MediaPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.PhxUnloadSharedStreamLevel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSoftObjectPtr<class UWorld>      Level                                                  (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bShouldBlockOnUnload                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PhxUnloadSharedStreamLevel(const class UObject* WorldContextObject, const TSoftObjectPtr<class UWorld> Level, const struct FLatentActionInfo& LatentInfo, bool bShouldBlockOnUnload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PhxUnloadSharedStreamLevel");

	Params::PhxGameplayStatics_PhxUnloadSharedStreamLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Level = Level;
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.bShouldBlockOnUnload = bShouldBlockOnUnload;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PlaceholderVO
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Speaker                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    AkEvent                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Line                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DisplayTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSoundComponent*               OverrideComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PlaceholderVO(class AActor* Speaker, class UAkAudioEvent* AkEvent, const class FString& Line, float DisplayTime, class UPhxSoundComponent* OverrideComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PlaceholderVO");

	Params::PhxGameplayStatics_PlaceholderVO Parms{};

	Parms.Speaker = Speaker;
	Parms.AkEvent = AkEvent;
	Parms.Line = std::move(Line);
	Parms.DisplayTime = DisplayTime;
	Parms.OverrideComponent = OverrideComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PlaceholderVOSubtitle
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           Speaker                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      RowName                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSoundComponent*               OverrideComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PlaceholderVOSubtitle(class AActor* Speaker, const class FName& RowName, class UPhxSoundComponent* OverrideComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PlaceholderVOSubtitle");

	Params::PhxGameplayStatics_PlaceholderVOSubtitle Parms{};

	Parms.Speaker = Speaker;
	Parms.RowName = RowName;
	Parms.OverrideComponent = OverrideComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PlayAdHocCinematicWithPerformers
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSoftObjectPath&           LevelSequenceAsset                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TMap<int32, struct FPhxAdHocCinematicPerformerInfo>&Performers                                             (Parm, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class APhxCharacter>     AnchorPeformer                                         (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMovieSceneSequencePlaybackSettings&PlaybackSettings                                       (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& GraphEntrySelector                                     (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAdHocLevelSequenceActor*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAdHocLevelSequenceActor* UPhxGameplayStatics::PlayAdHocCinematicWithPerformers(const class UObject* WorldContextObject, const struct FSoftObjectPath& LevelSequenceAsset, const TMap<int32, struct FPhxAdHocCinematicPerformerInfo>& Performers, TSoftObjectPtr<class APhxCharacter> AnchorPeformer, const struct FMovieSceneSequencePlaybackSettings& PlaybackSettings, const struct FCameraGraphEntrySelector& GraphEntrySelector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PlayAdHocCinematicWithPerformers");

	Params::PhxGameplayStatics_PlayAdHocCinematicWithPerformers Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelSequenceAsset = std::move(LevelSequenceAsset);
	Parms.Performers = std::move(Performers);
	Parms.AnchorPeformer = AnchorPeformer;
	Parms.PlaybackSettings = std::move(PlaybackSettings);
	Parms.GraphEntrySelector = std::move(GraphEntrySelector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.PlayAdHocCinematicWithPerformers_NoAnchorPerformer
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSoftObjectPath&           LevelSequenceAsset                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TMap<int32, struct FPhxAdHocCinematicPerformerInfo>&Performers                                             (Parm, NativeAccessSpecifierPublic)
// const struct FVector&                   ScriptedNodeLocation                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  ScriptedNodeRotation                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FMovieSceneSequencePlaybackSettings&PlaybackSettings                                       (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& GraphEntrySelector                                     (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAdHocLevelSequenceActor*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAdHocLevelSequenceActor* UPhxGameplayStatics::PlayAdHocCinematicWithPerformers_NoAnchorPerformer(const class UObject* WorldContextObject, const struct FSoftObjectPath& LevelSequenceAsset, const TMap<int32, struct FPhxAdHocCinematicPerformerInfo>& Performers, const struct FVector& ScriptedNodeLocation, const struct FRotator& ScriptedNodeRotation, const struct FMovieSceneSequencePlaybackSettings& PlaybackSettings, const struct FCameraGraphEntrySelector& GraphEntrySelector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PlayAdHocCinematicWithPerformers_NoAnchorPerformer");

	Params::PhxGameplayStatics_PlayAdHocCinematicWithPerformers_NoAnchorPerformer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelSequenceAsset = std::move(LevelSequenceAsset);
	Parms.Performers = std::move(Performers);
	Parms.ScriptedNodeLocation = std::move(ScriptedNodeLocation);
	Parms.ScriptedNodeRotation = std::move(ScriptedNodeRotation);
	Parms.PlaybackSettings = std::move(PlaybackSettings);
	Parms.GraphEntrySelector = std::move(GraphEntrySelector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.PlayerReachedCheckpoint
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Checkpoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PlayerReachedCheckpoint(class APhxCharacter* PlayerCharacter, class AActor* Checkpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PlayerReachedCheckpoint");

	Params::PhxGameplayStatics_PlayerReachedCheckpoint Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.Checkpoint = Checkpoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PopCinematicCameras
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PopCinematicCameras(class APhxCharacter* PlayerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PopCinematicCameras");

	Params::PhxGameplayStatics_PopCinematicCameras Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PopDynamicCameraState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& ExternalCamera                                         (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& TargetParent                                           (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PopDynamicCameraState(class APawn* PlayerCharacter, const struct FCameraGraphEntrySelector& ExternalCamera, const struct FCameraGraphEntrySelector& TargetParent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PopDynamicCameraState");

	Params::PhxGameplayStatics_PopDynamicCameraState Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.ExternalCamera = std::move(ExternalCamera);
	Parms.TargetParent = std::move(TargetParent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PopExternalCinematicCamera
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& ExternalCamera                                         (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& TargetParent                                           (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PopExternalCinematicCamera(class APawn* PlayerCharacter, const struct FCameraGraphEntrySelector& ExternalCamera, const struct FCameraGraphEntrySelector& TargetParent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PopExternalCinematicCamera");

	Params::PhxGameplayStatics_PopExternalCinematicCamera Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.ExternalCamera = std::move(ExternalCamera);
	Parms.TargetParent = std::move(TargetParent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PushDynamicCameraState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& ExternalCamera                                         (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& TargetParent                                           (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PushDynamicCameraState(class APawn* PlayerCharacter, const struct FCameraGraphEntrySelector& ExternalCamera, const struct FCameraGraphEntrySelector& TargetParent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PushDynamicCameraState");

	Params::PhxGameplayStatics_PushDynamicCameraState Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.ExternalCamera = std::move(ExternalCamera);
	Parms.TargetParent = std::move(TargetParent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.PushExternalCinematicCamera
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACameraActor*                     CameraActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& ExternalCamera                                         (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& TargetParent                                           (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::PushExternalCinematicCamera(class APawn* PlayerCharacter, class ACameraActor* CameraActor, const struct FCameraGraphEntrySelector& ExternalCamera, const struct FCameraGraphEntrySelector& TargetParent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "PushExternalCinematicCamera");

	Params::PhxGameplayStatics_PushExternalCinematicCamera Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.CameraActor = CameraActor;
	Parms.ExternalCamera = std::move(ExternalCamera);
	Parms.TargetParent = std::move(TargetParent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.RequestAnimatedCameraCut
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::RequestAnimatedCameraCut(class APhxCharacter* PlayerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "RequestAnimatedCameraCut");

	Params::PhxGameplayStatics_RequestAnimatedCameraCut Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.ResetContagionNoDeathAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::ResetContagionNoDeathAchievement(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "ResetContagionNoDeathAchievement");

	Params::PhxGameplayStatics_ResetContagionNoDeathAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.SetCharacterLoadout
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULoadoutDataAsset*                LoadoutData                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::SetCharacterLoadout(class APhxCharacter* Character, class ULoadoutDataAsset* LoadoutData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "SetCharacterLoadout");

	Params::PhxGameplayStatics_SetCharacterLoadout Parms{};

	Parms.Character = Character;
	Parms.LoadoutData = LoadoutData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.SetLevelSequenceSubSceneActive
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ULevelSequence*                   MasterLevelSequence                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULevelSequence*                   SubSequence                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::SetLevelSequenceSubSceneActive(class ULevelSequence* MasterLevelSequence, class ULevelSequence* SubSequence, bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "SetLevelSequenceSubSceneActive");

	Params::PhxGameplayStatics_SetLevelSequenceSubSceneActive Parms{};

	Parms.MasterLevelSequence = MasterLevelSequence;
	Parms.SubSequence = SubSequence;
	Parms.bActive = bActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.SetPauseHordeGame
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    bPause                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::SetPauseHordeGame(bool bPause, const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "SetPauseHordeGame");

	Params::PhxGameplayStatics_SetPauseHordeGame Parms{};

	Parms.bPause = bPause;
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.SweepMontage
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      Hit                                                    (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::SweepMontage(class UWorld* World, class APhxCharacter* Character, class UAnimMontage* Montage, struct FHitResult* Hit, int32 Segments)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "SweepMontage");

	Params::PhxGameplayStatics_SweepMontage Parms{};

	Parms.World = World;
	Parms.Character = Character;
	Parms.Montage = Montage;
	Parms.Segments = Segments;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.SweepMontageSegment
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      Hit                                                    (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   StartTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   EndTime                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      AccruedTransform                                       (Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::SweepMontageSegment(class UWorld* World, class APhxCharacter* Character, class UAnimMontage* Montage, struct FHitResult* Hit, float StartTime, float EndTime, struct FTransform* AccruedTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "SweepMontageSegment");

	Params::PhxGameplayStatics_SweepMontageSegment Parms{};

	Parms.World = World;
	Parms.Character = Character;
	Parms.Montage = Montage;
	Parms.StartTime = StartTime;
	Parms.EndTime = EndTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.SweepMontageWithRot
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      Hit                                                    (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FRotator&                  StartRotOverride                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Segments                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::SweepMontageWithRot(class UWorld* World, class APhxCharacter* Character, class UAnimMontage* Montage, struct FHitResult* Hit, const struct FRotator& StartRotOverride, int32 Segments)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "SweepMontageWithRot");

	Params::PhxGameplayStatics_SweepMontageWithRot Parms{};

	Parms.World = World;
	Parms.Character = Character;
	Parms.Montage = Montage;
	Parms.StartRotOverride = std::move(StartRotOverride);
	Parms.Segments = Segments;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayStatics.TeleportCharacter
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::TeleportCharacter(class APhxCharacter* Character, const struct FTransform& Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "TeleportCharacter");

	Params::PhxGameplayStatics_TeleportCharacter Parms{};

	Parms.Character = Character;
	Parms.Transform = std::move(Transform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.TraceBookmark
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Prefix                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Message                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::TraceBookmark(const class FString& Prefix, const class FString& Message)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "TraceBookmark");

	Params::PhxGameplayStatics_TraceBookmark Parms{};

	Parms.Prefix = std::move(Prefix);
	Parms.Message = std::move(Message);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.TransitionToCamera
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraGraphEntrySelector& CameraSelector                                         (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::TransitionToCamera(class APhxCharacter* PlayerCharacter, const struct FCameraGraphEntrySelector& CameraSelector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "TransitionToCamera");

	Params::PhxGameplayStatics_TransitionToCamera Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.CameraSelector = std::move(CameraSelector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.TriggerAchievementCompleted
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAchievements                        AchievementType                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::TriggerAchievementCompleted(const class UObject* WorldContextObject, EPhxAchievements AchievementType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "TriggerAchievementCompleted");

	Params::PhxGameplayStatics_TriggerAchievementCompleted Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementType = AchievementType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.UpdateAchievement5
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAchievement5Rooms                      Achievement5Room                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayStatics::UpdateAchievement5(const class UObject* WorldContextObject, EAchievement5Rooms Achievement5Room)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "UpdateAchievement5");

	Params::PhxGameplayStatics_UpdateAchievement5 Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Achievement5Room = Achievement5Room;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayStatics.WorldHasTag
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              TagToCheck                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameplayStatics::WorldHasTag(const class UObject* WorldContextObject, const struct FGameplayTag& TagToCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameplayStatics", "WorldHasTag");

	Params::PhxGameplayStatics_WorldHasTag Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TagToCheck = std::move(TagToCheck);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnAI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAISpawner_Character*          Spawner                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SpawnDelay                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_SpawnAI*    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_SpawnAI* UPhxAIBlueprintAction_SpawnAI::SpawnAI(class APhxAISpawner_Character* Spawner, float SpawnDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_SpawnAI", "SpawnAI");

	Params::PhxAIBlueprintAction_SpawnAI_SpawnAI Parms{};

	Parms.Spawner = Spawner;
	Parms.SpawnDelay = SpawnDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnAIFromComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPhxAISpawnerComponent_Character* SpawnerComponent                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SpawnDelay                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_SpawnAI*    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_SpawnAI* UPhxAIBlueprintAction_SpawnAI::SpawnAIFromComponent(class UPhxAISpawnerComponent_Character* SpawnerComponent, float SpawnDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_SpawnAI", "SpawnAIFromComponent");

	Params::PhxAIBlueprintAction_SpawnAI_SpawnAIFromComponent Parms{};

	Parms.SpawnerComponent = SpawnerComponent;
	Parms.SpawnDelay = SpawnDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnAIFromEncounterNetwork
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterNetwork*           EncounterNetwork                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class UPhxAICharacterDefinition>AICharacterDefinition                                  (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SpawnDelay                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_SpawnAI*    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_SpawnAI* UPhxAIBlueprintAction_SpawnAI::SpawnAIFromEncounterNetwork(class APhxAIEncounterNetwork* EncounterNetwork, TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition, float SpawnDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_SpawnAI", "SpawnAIFromEncounterNetwork");

	Params::PhxAIBlueprintAction_SpawnAI_SpawnAIFromEncounterNetwork Parms{};

	Parms.EncounterNetwork = EncounterNetwork;
	Parms.AICharacterDefinition = AICharacterDefinition;
	Parms.SpawnDelay = SpawnDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_SpawnAI.SpawnCompanion
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAISpawner_Companion*          Spawner                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_SpawnAI*    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_SpawnAI* UPhxAIBlueprintAction_SpawnAI::SpawnCompanion(class APhxAISpawner_Companion* Spawner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_SpawnAI", "SpawnCompanion");

	Params::PhxAIBlueprintAction_SpawnAI_SpawnCompanion Parms{};

	Parms.Spawner = Spawner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_SpawnAI.HandleAISpawned
// (Final, Native, Private)
// Parameters:
// class APhxAICharacter*                  SpawnedAI                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAISpawnResultCode                   ResultCode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SpawnUid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_SpawnAI::HandleAISpawned(class APhxAICharacter* SpawnedAI, EPhxAISpawnResultCode ResultCode, int32 SpawnUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_SpawnAI", "HandleAISpawned");

	Params::PhxAIBlueprintAction_SpawnAI_HandleAISpawned Parms{};

	Parms.SpawnedAI = SpawnedAI;
	Parms.ResultCode = ResultCode;
	Parms.SpawnUid = SpawnUid;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.AchievementUpdatePayload.OnGetAchievements
// (Final, Native, Public)
// Parameters:
// bool                                    bResult                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class USDSAchievement*>&   Achievements                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UAchievementUpdatePayload::OnGetAchievements(bool bResult, const TArray<class USDSAchievement*>& Achievements)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AchievementUpdatePayload", "OnGetAchievements");

	Params::AchievementUpdatePayload_OnGetAchievements Parms{};

	Parms.bResult = bResult;
	Parms.Achievements = std::move(Achievements);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMaterialCostMeterManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxMaterialCostMeterManager*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxMaterialCostMeterManager* UPhxMaterialCostMeterManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxMaterialCostMeterManager", "Get");

	Params::PhxMaterialCostMeterManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMaterialCostMeterManager.SetMaterialCostMeterVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Visibility                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMaterialCostMeterManager::SetMaterialCostMeterVisibility(ESlateVisibility Visibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMaterialCostMeterManager", "SetMaterialCostMeterVisibility");

	Params::PhxMaterialCostMeterManager_SetMaterialCostMeterVisibility Parms{};

	Parms.Visibility = Visibility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMaterialCostMeterManager.SetupMaterialCostMeter
// (Final, Native, Public, BlueprintCallable)

void UPhxMaterialCostMeterManager::SetupMaterialCostMeter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMaterialCostMeterManager", "SetupMaterialCostMeter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMaterialCostMeterManager.UpdateStats
// (Final, Native, Public)

void UPhxMaterialCostMeterManager::UpdateStats()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMaterialCostMeterManager", "UpdateStats");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMaterialCostMeterManager.IsMaterialCostMeterVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxMaterialCostMeterManager::IsMaterialCostMeterVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMaterialCostMeterManager", "IsMaterialCostMeterVisible");

	Params::PhxMaterialCostMeterManager_IsMaterialCostMeterVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.LogoScreenState.MediaOpenFailed
// (Final, Native, Protected)
// Parameters:
// const class FString&                    FailedUrl                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULogoScreenState::MediaOpenFailed(const class FString& FailedUrl)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LogoScreenState", "MediaOpenFailed");

	Params::LogoScreenState_MediaOpenFailed Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.LogoScreenState.MediaPlayerReachedEnd
// (Final, Native, Protected)

void ULogoScreenState::MediaPlayerReachedEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LogoScreenState", "MediaPlayerReachedEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAdHocLevelSequenceActor.OnPlaybackFinished
// (Final, Native, Public)

void APhxAdHocLevelSequenceActor::OnPlaybackFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAdHocLevelSequenceActor", "OnPlaybackFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MenuButton.Click
// (Final, Native, Public, BlueprintCallable)

void UMenuButton::Click()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuButton", "Click");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MenuButton.Hover
// (Final, Native, Public, BlueprintCallable)

void UMenuButton::Hover()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuButton", "Hover");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MenuButton.SetImageLabel
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UTexture*                         Texture                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMenuButton::SetImageLabel(class UTexture* Texture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuButton", "SetImageLabel");

	Params::MenuButton_SetImageLabel Parms{};

	Parms.Texture = Texture;

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


// Function Phoenix.MenuButton.SetTextColor
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FLinearColor&              LinearColor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMenuButton::SetTextColor(const struct FLinearColor& LinearColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuButton", "SetTextColor");

	Params::MenuButton_SetTextColor Parms{};

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

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


// Function Phoenix.MenuButton.SetTextLabel
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    TextLabel                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMenuButton::SetTextLabel(const class FString& TextLabel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuButton", "SetTextLabel");

	Params::MenuButton_SetTextLabel Parms{};

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

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


// Function Phoenix.PhxAcousticPortal.ClosePhxPortal
// (Final, Native, Public, BlueprintCallable)

void APhxAcousticPortal::ClosePhxPortal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAcousticPortal", "ClosePhxPortal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAcousticPortal.OpenPhxPortal
// (Final, Native, Public, BlueprintCallable)

void APhxAcousticPortal::OpenPhxPortal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAcousticPortal", "OpenPhxPortal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MicroSwitchboardPuzzleFSM.InteractExecuted
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMicroSwitchboardPuzzleFSM::InteractExecuted(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MicroSwitchboardPuzzleFSM", "InteractExecuted");

	Params::MicroSwitchboardPuzzleFSM_InteractExecuted Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Fixed.OnHolsterComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Fixed::OnHolsterComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Fixed", "OnHolsterComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Fixed.OnMontageBlendOut
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Fixed::OnMontageBlendOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Fixed", "OnMontageBlendOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Fixed.OnMontageCancelled
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Fixed::OnMontageCancelled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Fixed", "OnMontageCancelled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Fixed.OnMontageComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Fixed::OnMontageComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Fixed", "OnMontageComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Fixed.OnMontageInterrupted
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Fixed::OnMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Fixed", "OnMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Fixed.OnMoveComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Fixed::OnMoveComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Fixed", "OnMoveComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Fixed.OnUncrouchComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Fixed::OnUncrouchComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Fixed", "OnUncrouchComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventCharacterBaseState.HandleGamePaused
// (Final, Native, Protected)
// Parameters:
// bool                                    bPaused                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxScriptedEventCharacterBaseState::HandleGamePaused(bool bPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventCharacterBaseState", "HandleGamePaused");

	Params::PhxScriptedEventCharacterBaseState_HandleGamePaused Parms{};

	Parms.bPaused = bPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventCharacterBaseState.InputConfirm
// (Final, Native, Protected)

void UPhxScriptedEventCharacterBaseState::InputConfirm()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventCharacterBaseState", "InputConfirm");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIAbilityTask_AttackBase.HandleAttackStateBegin
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     InAttackState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIAbilityTask_AttackBase::HandleAttackStateBegin(class APhxCharacter* InCharacter, class UAttackState* InAttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIAbilityTask_AttackBase", "HandleAttackStateBegin");

	Params::PhxAIAbilityTask_AttackBase_HandleAttackStateBegin Parms{};

	Parms.InCharacter = InCharacter;
	Parms.InAttackState = InAttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIAbilityTask_AttackBase.HandleAttackStateFinished
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     InAttackState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIAbilityTask_AttackBase::HandleAttackStateFinished(class APhxCharacter* InCharacter, class UAttackState* InAttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIAbilityTask_AttackBase", "HandleAttackStateFinished");

	Params::PhxAIAbilityTask_AttackBase_HandleAttackStateFinished Parms{};

	Parms.InCharacter = InCharacter;
	Parms.InAttackState = InAttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIAbilityTask_RunAttackAbility.OnAbilityFinished
// (Final, Native, Private)
// Parameters:
// const struct FGameplayTag&              InTag                                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIAbilityTask_RunAttackAbility::OnAbilityFinished(const struct FGameplayTag& InTag, int32 NewCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIAbilityTask_RunAttackAbility", "OnAbilityFinished");

	Params::PhxAIAbilityTask_RunAttackAbility_OnAbilityFinished Parms{};

	Parms.InTag = std::move(InTag);
	Parms.NewCount = NewCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInteractionComponent.CanAutoExecute
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInteractableComponent*     focus                                                  (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInteractionComponent::CanAutoExecute(const class UInteractableComponent* focus) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInteractionComponent", "CanAutoExecute");

	Params::PhxCharacterInteractionComponent_CanAutoExecute Parms{};

	Parms.focus = focus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInteractionComponent.GetMostRecentInteraction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInteraction*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInteraction* UPhxCharacterInteractionComponent::GetMostRecentInteraction() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInteractionComponent", "GetMostRecentInteraction");

	Params::PhxCharacterInteractionComponent_GetMostRecentInteraction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerInteractionComponent.HandleGamePaused
// (Final, Native, Protected)
// Parameters:
// bool                                    InPaused                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxPlayerInteractionComponent::HandleGamePaused(bool InPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerInteractionComponent", "HandleGamePaused");

	Params::PhxPlayerInteractionComponent_HandleGamePaused Parms{};

	Parms.InPaused = InPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.AddKeyMappingForInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ActionName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AxisScale                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      NewKey                                                 (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::AddKeyMappingForInput(class FName ActionName, float AxisScale, const struct FKey& NewKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "AddKeyMappingForInput");

	Params::PhxPlayerController_AddKeyMappingForInput Parms{};

	Parms.ActionName = ActionName;
	Parms.AxisScale = AxisScale;
	Parms.NewKey = std::move(NewKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.AdjustCuedRespawn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   RespawnTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::AdjustCuedRespawn(float RespawnTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "AdjustCuedRespawn");

	Params::PhxPlayerController_AdjustCuedRespawn Parms{};

	Parms.RespawnTime = RespawnTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.ApplyInputMappingSettings
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxInputMappingSettings*         NewInputMappingAsset                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::ApplyInputMappingSettings(class UPhxInputMappingSettings* NewInputMappingAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "ApplyInputMappingSettings");

	Params::PhxPlayerController_ApplyInputMappingSettings Parms{};

	Parms.NewInputMappingAsset = NewInputMappingAsset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.ApplySavedInputSettings
// (Final, Native, Public)
// Parameters:
// class UPhxInputMappingSettings*         InputMappingAsset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::ApplySavedInputSettings(class UPhxInputMappingSettings* InputMappingAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "ApplySavedInputSettings");

	Params::PhxPlayerController_ApplySavedInputSettings Parms{};

	Parms.InputMappingAsset = InputMappingAsset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.AttachCameraRigToPawn
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::AttachCameraRigToPawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "AttachCameraRigToPawn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.CloseCombatTutorial
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::CloseCombatTutorial()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "CloseCombatTutorial");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.CopyKeyboardActionInputMapping
// (Final, Native, Public)
// Parameters:
// class UPhxInputMappingSettings*         InputSettings                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FPhxInputActionMappingSetting>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FPhxInputActionMappingSetting> APhxPlayerController::CopyKeyboardActionInputMapping(class UPhxInputMappingSettings* InputSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "CopyKeyboardActionInputMapping");

	Params::PhxPlayerController_CopyKeyboardActionInputMapping Parms{};

	Parms.InputSettings = InputSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.CopyKeyboardAxisInputMapping
// (Final, Native, Public)
// Parameters:
// class UPhxInputMappingSettings*         InputSettings                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FPhxInputAxisMappingSetting>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FPhxInputAxisMappingSetting> APhxPlayerController::CopyKeyboardAxisInputMapping(class UPhxInputMappingSettings* InputSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "CopyKeyboardAxisInputMapping");

	Params::PhxPlayerController_CopyKeyboardAxisInputMapping Parms{};

	Parms.InputSettings = InputSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.CueRespawn
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bFast                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OverrideRespawnInterval                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::CueRespawn(bool bFast, float OverrideRespawnInterval)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "CueRespawn");

	Params::PhxPlayerController_CueRespawn Parms{};

	Parms.bFast = bFast;
	Parms.OverrideRespawnInterval = OverrideRespawnInterval;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.EnterBenchmarkPause
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::EnterBenchmarkPause()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "EnterBenchmarkPause");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.ExitBenchmarkPause
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::ExitBenchmarkPause()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "ExitBenchmarkPause");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.GetCheatManager
// (Final, Native, Public)
// Parameters:
// class UPhxCheatManager*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCheatManager* APhxPlayerController::GetCheatManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "GetCheatManager");

	Params::PhxPlayerController_GetCheatManager Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.GetPlayerCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxPlayerCharacter*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxPlayerCharacter* APhxPlayerController::GetPlayerCharacter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "GetPlayerCharacter");

	Params::PhxPlayerController_GetPlayerCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.LockInput
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::LockInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "LockInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.LockOutActions
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::LockOutActions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "LockOutActions");

	Params::PhxPlayerController_LockOutActions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.LockOutCorpseStomp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::LockOutCorpseStomp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "LockOutCorpseStomp");

	Params::PhxPlayerController_LockOutCorpseStomp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.LockOutEquipment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::LockOutEquipment()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "LockOutEquipment");

	Params::PhxPlayerController_LockOutEquipment Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.LockOutInteractions
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::LockOutInteractions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "LockOutInteractions");

	Params::PhxPlayerController_LockOutInteractions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.LockOutMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::LockOutMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "LockOutMenu");

	Params::PhxPlayerController_LockOutMenu Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.LockOutMovement
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::LockOutMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "LockOutMovement");

	Params::PhxPlayerController_LockOutMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.OnDialogueStarted
// (Final, Native, Private)
// Parameters:
// class AActor*                           SpeakingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDialogueNode&             Dialogue                                               (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxPlayerController::OnDialogueStarted(class AActor* SpeakingActor, const struct FDialogueNode& Dialogue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "OnDialogueStarted");

	Params::PhxPlayerController_OnDialogueStarted Parms{};

	Parms.SpeakingActor = SpeakingActor;
	Parms.Dialogue = std::move(Dialogue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.OnInteractionExecuted
// (Final, Native, Public)
// Parameters:
// const class UInteraction*               Interaction                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::OnInteractionExecuted(const class UInteraction* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "OnInteractionExecuted");

	Params::PhxPlayerController_OnInteractionExecuted Parms{};

	Parms.Interaction = Interaction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.OnScriptedEventSkipFinished
// (Final, Native, Public)

void APhxPlayerController::OnScriptedEventSkipFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "OnScriptedEventSkipFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.PopDisableStreamingVolumes
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::PopDisableStreamingVolumes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "PopDisableStreamingVolumes");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.ProcessQueuedCombatTutorial
// (Final, Native, Protected)

void APhxPlayerController::ProcessQueuedCombatTutorial()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "ProcessQueuedCombatTutorial");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.PushDisableStreamingVolumes
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::PushDisableStreamingVolumes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "PushDisableStreamingVolumes");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.RemoveKeyMappingForInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ActionName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AxisScale                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      CurrentKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::RemoveKeyMappingForInput(class FName ActionName, float AxisScale, const struct FKey& CurrentKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "RemoveKeyMappingForInput");

	Params::PhxPlayerController_RemoveKeyMappingForInput Parms{};

	Parms.ActionName = ActionName;
	Parms.AxisScale = AxisScale;
	Parms.CurrentKey = std::move(CurrentKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.RemoveSkipScriptedEventPromptIfOnScreen
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::RemoveSkipScriptedEventPromptIfOnScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "RemoveSkipScriptedEventPromptIfOnScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.RequestCombatTutorial
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TutorialTag                                            (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::RequestCombatTutorial(const struct FGameplayTag& TutorialTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "RequestCombatTutorial");

	Params::PhxPlayerController_RequestCombatTutorial Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.RequestOutOfAmmoUI
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::RequestOutOfAmmoUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "RequestOutOfAmmoUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.RequestOutOfChargeUI
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::RequestOutOfChargeUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "RequestOutOfChargeUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.ResetInputMappingToDefaults
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::ResetInputMappingToDefaults()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "ResetInputMappingToDefaults");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SaveDefaultKeyboardMappings
// (Final, Native, Public)
// Parameters:
// class UPhxInputMappingSettings*         InputSettings                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::SaveDefaultKeyboardMappings(class UPhxInputMappingSettings* InputSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SaveDefaultKeyboardMappings");

	Params::PhxPlayerController_SaveDefaultKeyboardMappings Parms{};

	Parms.InputSettings = InputSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SaveKeyboardMappingInputs
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::SaveKeyboardMappingInputs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SaveKeyboardMappingInputs");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SendAudioLogInterruptEvent
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::SendAudioLogInterruptEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SendAudioLogInterruptEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SetAllowPhotoMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInAllowPhotoMode                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::SetAllowPhotoMode(bool bInAllowPhotoMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SetAllowPhotoMode");

	Params::PhxPlayerController_SetAllowPhotoMode Parms{};

	Parms.bInAllowPhotoMode = bInAllowPhotoMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SetFullScreenMediaPlaying
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    OnOff                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::SetFullScreenMediaPlaying(bool OnOff)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SetFullScreenMediaPlaying");

	Params::PhxPlayerController_SetFullScreenMediaPlaying Parms{};

	Parms.OnOff = OnOff;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SetPhotoModeActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::SetPhotoModeActive(bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SetPhotoModeActive");

	Params::PhxPlayerController_SetPhotoModeActive Parms{};

	Parms.bActive = bActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SetPlayerAim
// (Final, Exec, Native, Public)
// Parameters:
// float                                   Pitch                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Yaw                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerController::SetPlayerAim(float Pitch, float Yaw)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SetPlayerAim");

	Params::PhxPlayerController_SetPlayerAim Parms{};

	Parms.Pitch = Pitch;
	Parms.Yaw = Yaw;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.SkipScriptedEvent
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::SkipScriptedEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "SkipScriptedEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.ToggleInventoryClassVersion
// (Final, Exec, Native, Public)

void APhxPlayerController::ToggleInventoryClassVersion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "ToggleInventoryClassVersion");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.UnlockInput
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::UnlockInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "UnlockInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.UpdateKeyMappingForInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ActionName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AxisScale                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      CurrentKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      NewKey                                                 (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::UpdateKeyMappingForInput(class FName ActionName, float AxisScale, const struct FKey& CurrentKey, const struct FKey& NewKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "UpdateKeyMappingForInput");

	Params::PhxPlayerController_UpdateKeyMappingForInput Parms{};

	Parms.ActionName = ActionName;
	Parms.AxisScale = AxisScale;
	Parms.CurrentKey = std::move(CurrentKey);
	Parms.NewKey = std::move(NewKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.UpdateKeyMappingList
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerController::UpdateKeyMappingList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "UpdateKeyMappingList");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerController.GetCameraRig
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCameraRig*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCameraRig* APhxPlayerController::GetCameraRig() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "GetCameraRig");

	Params::PhxPlayerController_GetCameraRig Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.GetInputMappingSettings
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxInputMappingSettings*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxInputMappingSettings* APhxPlayerController::GetInputMappingSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "GetInputMappingSettings");

	Params::PhxPlayerController_GetInputMappingSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.GetUIComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxPlayerControllerUIComponent*  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxPlayerControllerUIComponent* APhxPlayerController::GetUIComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "GetUIComponent");

	Params::PhxPlayerController_GetUIComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.IsControllerInState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UState>               StateClass                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::IsControllerInState(TSubclassOf<class UState> StateClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "IsControllerInState");

	Params::PhxPlayerController_IsControllerInState Parms{};

	Parms.StateClass = StateClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.IsFullScreenMediaPlaying
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::IsFullScreenMediaPlaying() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "IsFullScreenMediaPlaying");

	Params::PhxPlayerController_IsFullScreenMediaPlaying Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.IsGamePadInUse
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::IsGamePadInUse() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "IsGamePadInUse");

	Params::PhxPlayerController_IsGamePadInUse Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.IsGamePadLastOrRecentlyUsed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   TimeThreshold                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::IsGamePadLastOrRecentlyUsed(float TimeThreshold) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "IsGamePadLastOrRecentlyUsed");

	Params::PhxPlayerController_IsGamePadLastOrRecentlyUsed Parms{};

	Parms.TimeThreshold = TimeThreshold;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.IsPhotoModeActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::IsPhotoModeActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "IsPhotoModeActive");

	Params::PhxPlayerController_IsPhotoModeActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.IsPhotoModeAllowed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::IsPhotoModeAllowed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "IsPhotoModeAllowed");

	Params::PhxPlayerController_IsPhotoModeAllowed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerController.IsUsingStreamingVolumes
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerController::IsUsingStreamingVolumes() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerController", "IsUsingStreamingVolumes");

	Params::PhxPlayerController_IsUsingStreamingVolumes Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHitmaskComponent.RenderHit
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHitmaskComponent::RenderHit(const struct FVector& Position, class FName BoneName, float Damage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHitmaskComponent", "RenderHit");

	Params::PhxHitmaskComponent_RenderHit Parms{};

	Parms.Position = std::move(Position);
	Parms.BoneName = BoneName;
	Parms.Damage = Damage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.JumpToSplineDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InDistanceAlongSpline                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMovementSpline::JumpToSplineDistance(float InDistanceAlongSpline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "JumpToSplineDistance");

	Params::PhxMovementSpline_JumpToSplineDistance Parms{};

	Parms.InDistanceAlongSpline = InDistanceAlongSpline;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.JumpToSplinePointActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxMovementSplinePoint*          InSplinePoint                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMovementSpline::JumpToSplinePointActor(class APhxMovementSplinePoint* InSplinePoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "JumpToSplinePointActor");

	Params::PhxMovementSpline_JumpToSplinePointActor Parms{};

	Parms.InSplinePoint = InSplinePoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.JumpToSplinePointIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InPointIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMovementSpline::JumpToSplinePointIndex(int32 InPointIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "JumpToSplinePointIndex");

	Params::PhxMovementSpline_JumpToSplinePointIndex Parms{};

	Parms.InPointIndex = InPointIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.SetMovementLoopBounds
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFloatRange&               InRange                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMovementSpline::SetMovementLoopBounds(const struct FFloatRange& InRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "SetMovementLoopBounds");

	Params::PhxMovementSpline_SetMovementLoopBounds Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.SetShouldLoopSplineMovement
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldLoopSplineMovement                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMovementSpline::SetShouldLoopSplineMovement(bool bShouldLoopSplineMovement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "SetShouldLoopSplineMovement");

	Params::PhxMovementSpline_SetShouldLoopSplineMovement Parms{};

	Parms.bShouldLoopSplineMovement = bShouldLoopSplineMovement;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.StartMovement
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InMoveActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMovementSpline::StartMovement(class AActor* InMoveActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "StartMovement");

	Params::PhxMovementSpline_StartMovement Parms{};

	Parms.InMoveActor = InMoveActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.StopMovement
// (Final, Native, Public, BlueprintCallable)

void APhxMovementSpline::StopMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "StopMovement");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMovementSpline.GetCurrentMovementSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxMovementSpline::GetCurrentMovementSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMovementSpline", "GetCurrentMovementSpeed");

	Params::PhxMovementSpline_GetCurrentMovementSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPhysicalMovementSpline.RegisterBaseMovementCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       BaseMovementCharacter                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPhysicalMovementSpline::RegisterBaseMovementCharacter(class ACharacter* BaseMovementCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPhysicalMovementSpline", "RegisterBaseMovementCharacter");

	Params::PhxPhysicalMovementSpline_RegisterBaseMovementCharacter Parms{};

	Parms.BaseMovementCharacter = BaseMovementCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPhysicalMovementSpline.UnregisterBaseMovementCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       BaseMovementCharacter                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPhysicalMovementSpline::UnregisterBaseMovementCharacter(class ACharacter* BaseMovementCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPhysicalMovementSpline", "UnregisterBaseMovementCharacter");

	Params::PhxPhysicalMovementSpline_UnregisterBaseMovementCharacter Parms{};

	Parms.BaseMovementCharacter = BaseMovementCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.GetNumEnemiesAwareOfPlayerOfType
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayTag&              CharacterTag                                           (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxAIGameStateManager::GetNumEnemiesAwareOfPlayerOfType(const struct FGameplayTag& CharacterTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "GetNumEnemiesAwareOfPlayerOfType");

	Params::PhxAIGameStateManager_GetNumEnemiesAwareOfPlayerOfType Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIBodyPartsKilled
// (Final, Native, Private, HasOutParams)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EPhxBodyPartType>&         BodyPartsKilled                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           InstigatorActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIBodyPartsKilled(class APhxCharacter* Character, const TArray<EPhxBodyPartType>& BodyPartsKilled, class AActor* InstigatorActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIBodyPartsKilled");

	Params::PhxAIGameStateManager_HandleAIBodyPartsKilled Parms{};

	Parms.Character = Character;
	Parms.BodyPartsKilled = std::move(BodyPartsKilled);
	Parms.InstigatorActor = InstigatorActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIDestroyed");

	Params::PhxAIGameStateManager_HandleAIDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIGRPGrabbed
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIGRPGrabbed(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIGRPGrabbed");

	Params::PhxAIGameStateManager_HandleAIGRPGrabbed Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIKilledByHazard
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEnvironmentalHazard*             HazardActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIKilledByHazard(class APhxCharacter* Character, class AEnvironmentalHazard* HazardActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIKilledByHazard");

	Params::PhxAIGameStateManager_HandleAIKilledByHazard Parms{};

	Parms.Character = Character;
	Parms.HazardActor = HazardActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIKilledByMeleeWeapon
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AMeleeWeapon*                     Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxMeleeAttackDefinition*        AttackDef                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIKilledByMeleeWeapon(class APhxCharacter* Character, class AMeleeWeapon* Weapon, class UPhxMeleeAttackDefinition* AttackDef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIKilledByMeleeWeapon");

	Params::PhxAIGameStateManager_HandleAIKilledByMeleeWeapon Parms{};

	Parms.Character = Character;
	Parms.Weapon = Weapon;
	Parms.AttackDef = AttackDef;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAILimboBegin
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAILimboBegin(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAILimboBegin");

	Params::PhxAIGameStateManager_HandleAILimboBegin Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIMutateBegin
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIMutateBegin(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIMutateBegin");

	Params::PhxAIGameStateManager_HandleAIMutateBegin Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIPostDeathBegin
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIPostDeathBegin(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIPostDeathBegin");

	Params::PhxAIGameStateManager_HandleAIPostDeathBegin Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIResurrectBegin
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIResurrectBegin(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIResurrectBegin");

	Params::PhxAIGameStateManager_HandleAIResurrectBegin Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleAIVirusBegin
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleAIVirusBegin(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleAIVirusBegin");

	Params::PhxAIGameStateManager_HandleAIVirusBegin Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.HandleTakeAnyDamage
// (Final, Native, Private)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameStateManager::HandleTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "HandleTakeAnyDamage");

	Params::PhxAIGameStateManager_HandleTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameStateManager.GetGameState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxAIGameState                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxAIGameState UPhxAIGameStateManager::GetGameState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "GetGameState");

	Params::PhxAIGameStateManager_GetGameState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameStateManager.GetNumActiveEnemies
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxAIGameStateManager::GetNumActiveEnemies() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "GetNumActiveEnemies");

	Params::PhxAIGameStateManager_GetNumActiveEnemies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameStateManager.IsLastEnemyTargetingPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIGameStateManager::IsLastEnemyTargetingPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "IsLastEnemyTargetingPlayer");

	Params::PhxAIGameStateManager_IsLastEnemyTargetingPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameStateManager.K2_GetActiveEnemies
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class APhxAICharacter*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class APhxAICharacter*> UPhxAIGameStateManager::K2_GetActiveEnemies() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameStateManager", "K2_GetActiveEnemies");

	Params::PhxAIGameStateManager_K2_GetActiveEnemies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.MotionMatchCostRetriever.OnAISpawned
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ACharacter*                       Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMotionMatchCostRetriever::OnAISpawned(class ACharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostRetriever", "OnAISpawned");

	Params::MotionMatchCostRetriever_OnAISpawned Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MotionMatchCostRetriever.Reset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    TestRunning                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMotionMatchCostRetriever::Reset(bool TestRunning)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostRetriever", "Reset");

	Params::MotionMatchCostRetriever_Reset Parms{};

	Parms.TestRunning = TestRunning;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.MotionMatchCostRetriever.UpdateCost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMotionMatchCostRetriever::UpdateCost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchCostRetriever", "UpdateCost");

	Params::MotionMatchCostRetriever_UpdateCost Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundStateLibrary.GetActiveStates
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// TSet<class FString>                     ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

TSet<class FString> UPhxSoundStateLibrary::GetActiveStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundStateLibrary", "GetActiveStates");

	Params::PhxSoundStateLibrary_GetActiveStates Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundStateLibrary.ResetStates
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSet<class UAkStateValue*>&       KeepValues                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const TSet<class FName>&                KeepGroupNames                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSoundStateLibrary::ResetStates(const TSet<class UAkStateValue*>& KeepValues, const TSet<class FName>& KeepGroupNames)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundStateLibrary", "ResetStates");

	Params::PhxSoundStateLibrary_ResetStates Parms{};

	Parms.KeepValues = std::move(KeepValues);
	Parms.KeepGroupNames = std::move(KeepGroupNames);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicAnimaticPlayer.FinishPlayingVideo
// (Final, Native, Public, BlueprintCallable)

void APhxCinematicAnimaticPlayer::FinishPlayingVideo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicAnimaticPlayer", "FinishPlayingVideo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicAnimaticPlayer.PlayVideo
// (Final, Native, Public, BlueprintCallable)

void APhxCinematicAnimaticPlayer::PlayVideo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicAnimaticPlayer", "PlayVideo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicAnimaticPlayer.ReceiveForceFinishVideoPlayback
// (Event, Protected, BlueprintEvent)

void APhxCinematicAnimaticPlayer::ReceiveForceFinishVideoPlayback()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicAnimaticPlayer", "ReceiveForceFinishVideoPlayback");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxCinematicAnimaticPlayer.ReceivePlayVideo
// (Event, Protected, BlueprintEvent)

void APhxCinematicAnimaticPlayer::ReceivePlayVideo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicAnimaticPlayer", "ReceivePlayVideo");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PauseMenuState.ScreenCreated
// (Final, Native, Private)
// Parameters:
// class USDSScreenWidget*                 NewScreen                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPauseMenuState::ScreenCreated(class USDSScreenWidget* NewScreen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PauseMenuState", "ScreenCreated");

	Params::PauseMenuState_ScreenCreated Parms{};

	Parms.NewScreen = NewScreen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PauseMenuWidget.SetSelection
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   ButtonIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPlayAnimation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPauseMenuWidget::SetSelection(int32 ButtonIndex, bool bPlayAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PauseMenuWidget", "SetSelection");

	Params::PauseMenuWidget_SetSelection Parms{};

	Parms.ButtonIndex = ButtonIndex;
	Parms.bPlayAnimation = bPlayAnimation;

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


// Function Phoenix.PauseMenuWidget.GetLevelSelectWidget
// (Final, Native, Public, Const)
// Parameters:
// class ULevelSelectWidget*               ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULevelSelectWidget* UPauseMenuWidget::GetLevelSelectWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PauseMenuWidget", "GetLevelSelectWidget");

	Params::PauseMenuWidget_GetLevelSelectWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PauseMenuWidget.GetOptionsWidget
// (Final, Native, Public, Const)
// Parameters:
// class UOptionsWidget*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UOptionsWidget* UPauseMenuWidget::GetOptionsWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PauseMenuWidget", "GetOptionsWidget");

	Params::PauseMenuWidget_GetOptionsWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToActorForce.ApplyPhxRootMotionMoveToActorForce
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FPhxRootMotionMoveToActorSettings*MoveToActorSettings                                    (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// class UPhxAbilityTask_ApplyRootMotionMoveToActorForce*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAbilityTask_ApplyRootMotionMoveToActorForce* UPhxAbilityTask_ApplyRootMotionMoveToActorForce::ApplyPhxRootMotionMoveToActorForce(struct FPhxRootMotionMoveToActorSettings* MoveToActorSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAbilityTask_ApplyRootMotionMoveToActorForce", "ApplyPhxRootMotionMoveToActorForce");

	Params::PhxAbilityTask_ApplyRootMotionMoveToActorForce_ApplyPhxRootMotionMoveToActorForce Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.DestroyAllCorpses
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_EncounterGroupActions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_EncounterGroupActions* UPhxAIBlueprintAction_EncounterGroupActions::DestroyAllCorpses(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EncounterGroupActions", "DestroyAllCorpses");

	Params::PhxAIBlueprintAction_EncounterGroupActions_DestroyAllCorpses Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.EndEncounterGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_EncounterGroupActions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_EncounterGroupActions* UPhxAIBlueprintAction_EncounterGroupActions::EndEncounterGroup(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EncounterGroupActions", "EndEncounterGroup");

	Params::PhxAIBlueprintAction_EncounterGroupActions_EndEncounterGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.FinishEncounterGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_EncounterGroupActions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_EncounterGroupActions* UPhxAIBlueprintAction_EncounterGroupActions::FinishEncounterGroup(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EncounterGroupActions", "FinishEncounterGroup");

	Params::PhxAIBlueprintAction_EncounterGroupActions_FinishEncounterGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_EncounterGroupActions.KillEncounterGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_EncounterGroupActions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_EncounterGroupActions* UPhxAIBlueprintAction_EncounterGroupActions::KillEncounterGroup(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EncounterGroupActions", "KillEncounterGroup");

	Params::PhxAIBlueprintAction_EncounterGroupActions_KillEncounterGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToDynamicForce.ApplyPhxRootMotionMoveToDynamicForce
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FPhxRootMotionMoveToDynamicForceSettings*MoveToLocationSettings                                 (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// class UPhxAbilityTask_ApplyRootMotionMoveToDynamicForce*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAbilityTask_ApplyRootMotionMoveToDynamicForce* UPhxAbilityTask_ApplyRootMotionMoveToDynamicForce::ApplyPhxRootMotionMoveToDynamicForce(struct FPhxRootMotionMoveToDynamicForceSettings* MoveToLocationSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAbilityTask_ApplyRootMotionMoveToDynamicForce", "ApplyPhxRootMotionMoveToDynamicForce");

	Params::PhxAbilityTask_ApplyRootMotionMoveToDynamicForce_ApplyPhxRootMotionMoveToDynamicForce Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToForce.ApplyPhxRootMotionMoveToForce
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FPhxRootMotionMoveToSettings*    RootMotionMoveToSettings                               (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// class UPhxAbilityTask_ApplyRootMotionMoveToForce*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAbilityTask_ApplyRootMotionMoveToForce* UPhxAbilityTask_ApplyRootMotionMoveToForce::ApplyPhxRootMotionMoveToForce(struct FPhxRootMotionMoveToSettings* RootMotionMoveToSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAbilityTask_ApplyRootMotionMoveToForce", "ApplyPhxRootMotionMoveToForce");

	Params::PhxAbilityTask_ApplyRootMotionMoveToForce_ApplyPhxRootMotionMoveToForce Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToForceArc.ApplyPhxRootMotionMoveToForceArc
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FPhxRootMotionMoveToArcSettings* RootMotionMoveToSettings                               (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// class UPhxAbilityTask_ApplyRootMotionMoveToForceArc*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAbilityTask_ApplyRootMotionMoveToForceArc* UPhxAbilityTask_ApplyRootMotionMoveToForceArc::ApplyPhxRootMotionMoveToForceArc(struct FPhxRootMotionMoveToArcSettings* RootMotionMoveToSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAbilityTask_ApplyRootMotionMoveToForceArc", "ApplyPhxRootMotionMoveToForceArc");

	Params::PhxAbilityTask_ApplyRootMotionMoveToForceArc_ApplyPhxRootMotionMoveToForceArc Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAbilityTask_ApplyRootMotionMoveToForceXY.ApplyPhxRootMotionMoveToForceXY
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FPhxRootMotionMoveToLocationXYSettings*MoveToLocationSettings                                 (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// class UPhxAbilityTask_ApplyRootMotionMoveToForceXY*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAbilityTask_ApplyRootMotionMoveToForceXY* UPhxAbilityTask_ApplyRootMotionMoveToForceXY::ApplyPhxRootMotionMoveToForceXY(struct FPhxRootMotionMoveToLocationXYSettings* MoveToLocationSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAbilityTask_ApplyRootMotionMoveToForceXY", "ApplyPhxRootMotionMoveToForceXY");

	Params::PhxAbilityTask_ApplyRootMotionMoveToForceXY_ApplyPhxRootMotionMoveToForceXY Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.BeginEncounterGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_BeginEncounterGroup*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_BeginEncounterGroup* UPhxAIBlueprintAction_BeginEncounterGroup::BeginEncounterGroup(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_BeginEncounterGroup", "BeginEncounterGroup");

	Params::PhxAIBlueprintAction_BeginEncounterGroup_BeginEncounterGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.ForceBeginEncounterGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_BeginEncounterGroup*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_BeginEncounterGroup* UPhxAIBlueprintAction_BeginEncounterGroup::ForceBeginEncounterGroup(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_BeginEncounterGroup", "ForceBeginEncounterGroup");

	Params::PhxAIBlueprintAction_BeginEncounterGroup_ForceBeginEncounterGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.OnEncounterGroupStreamedOut
// (Final, Native, Private)
// Parameters:
// class APhxAIEncounterGroup*             InEncounterGroup                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_BeginEncounterGroup::OnEncounterGroupStreamedOut(class APhxAIEncounterGroup* InEncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_BeginEncounterGroup", "OnEncounterGroupStreamedOut");

	Params::PhxAIBlueprintAction_BeginEncounterGroup_OnEncounterGroupStreamedOut Parms{};

	Parms.InEncounterGroup = InEncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_BeginEncounterGroup.OnLastWaveCompleted
// (Final, Native, Private)
// Parameters:
// class APhxAIEncounterGroup*             InEncounterGroup                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIEncounterGroupWaveDescriptor*InWaveDescriptor                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_BeginEncounterGroup::OnLastWaveCompleted(class APhxAIEncounterGroup* InEncounterGroup, class UPhxAIEncounterGroupWaveDescriptor* InWaveDescriptor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_BeginEncounterGroup", "OnLastWaveCompleted");

	Params::PhxAIBlueprintAction_BeginEncounterGroup_OnLastWaveCompleted Parms{};

	Parms.InEncounterGroup = InEncounterGroup;
	Parms.InWaveDescriptor = InWaveDescriptor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.ExitEncounterNetwork
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetwork*           EncounterNetwork                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTeleport                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_ExitEncounterNetwork*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_ExitEncounterNetwork* UPhxAIBlueprintAction_ExitEncounterNetwork::ExitEncounterNetwork(class APhxAICharacter* Character, class APhxAIEncounterNetwork* EncounterNetwork, bool bTeleport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_ExitEncounterNetwork", "ExitEncounterNetwork");

	Params::PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetwork Parms{};

	Parms.Character = Character;
	Parms.EncounterNetwork = EncounterNetwork;
	Parms.bTeleport = bTeleport;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.ExitEncounterNetworkAtNode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetworkTraversalNode*Exit                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTeleport                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_ExitEncounterNetwork*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_ExitEncounterNetwork* UPhxAIBlueprintAction_ExitEncounterNetwork::ExitEncounterNetworkAtNode(class APhxAICharacter* Character, class APhxAIEncounterNetworkTraversalNode* Exit, bool bTeleport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_ExitEncounterNetwork", "ExitEncounterNetworkAtNode");

	Params::PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkAtNode Parms{};

	Parms.Character = Character;
	Parms.Exit = Exit;
	Parms.bTeleport = bTeleport;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.ExitEncounterNetworkGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class UPhxAICharacterDefinition>AICharacterDefinition                                  (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetwork*           EncounterNetwork                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTeleport                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_ExitEncounterNetwork::ExitEncounterNetworkGroup(class APhxAIEncounterGroup* EncounterGroup, TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition, class APhxAIEncounterNetwork* EncounterNetwork, bool bTeleport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_ExitEncounterNetwork", "ExitEncounterNetworkGroup");

	Params::PhxAIBlueprintAction_ExitEncounterNetwork_ExitEncounterNetworkGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.AICharacterDefinition = AICharacterDefinition;
	Parms.EncounterNetwork = EncounterNetwork;
	Parms.bTeleport = bTeleport;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_ExitEncounterNetwork.HandleExitEncounterNetworkCompleted
// (Final, Native, Private)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_ExitEncounterNetwork::HandleExitEncounterNetworkCompleted(bool bSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_ExitEncounterNetwork", "HandleExitEncounterNetworkCompleted");

	Params::PhxAIBlueprintAction_ExitEncounterNetwork_HandleExitEncounterNetworkCompleted Parms{};

	Parms.bSuccess = bSuccess;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxVehicleSimulationComponent.DebugDrawSuspension
// (Final, Native, Public, BlueprintCallable)

void UPhxVehicleSimulationComponent::DebugDrawSuspension()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "DebugDrawSuspension");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxVehicleSimulationComponent.GetCurrentPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPhxVehicleSimulationComponent::GetCurrentPosition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "GetCurrentPosition");

	Params::PhxVehicleSimulationComponent_GetCurrentPosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehicleSimulationComponent.GetCurrentRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UPhxVehicleSimulationComponent::GetCurrentRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "GetCurrentRotation");

	Params::PhxVehicleSimulationComponent_GetCurrentRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehicleSimulationComponent.GetEngineSpeedRPM
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxVehicleSimulationComponent::GetEngineSpeedRPM() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "GetEngineSpeedRPM");

	Params::PhxVehicleSimulationComponent_GetEngineSpeedRPM Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehicleSimulationComponent.GetEngineTorque
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxVehicleSimulationComponent::GetEngineTorque() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "GetEngineTorque");

	Params::PhxVehicleSimulationComponent_GetEngineTorque Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehicleSimulationComponent.GetGear
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxVehicleSimulationComponent::GetGear() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "GetGear");

	Params::PhxVehicleSimulationComponent_GetGear Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehicleSimulationComponent.GetSpeedMPH
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxVehicleSimulationComponent::GetSpeedMPH() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "GetSpeedMPH");

	Params::PhxVehicleSimulationComponent_GetSpeedMPH Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehicleSimulationComponent.GetTractionForce
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxVehicleSimulationComponent::GetTractionForce() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicleSimulationComponent", "GetTractionForce");

	Params::PhxVehicleSimulationComponent_GetTractionForce Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacterAwarenessComponent.HandleOwnerDied
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterAwarenessComponent::HandleOwnerDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterAwarenessComponent", "HandleOwnerDied");

	Params::PhxAICharacterAwarenessComponent_HandleOwnerDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLineBatchComponent.Clear
// (Final, Native, Public, BlueprintCallable)

void UPhxLineBatchComponent::Clear()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLineBatchComponent", "Clear");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLineBatchComponent.DrawNewLine
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   StartLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndLocation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              Color                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   DepthPriority                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLineBatchComponent::DrawNewLine(const struct FVector& StartLocation, const struct FVector& EndLocation, const struct FLinearColor& Color, uint8 DepthPriority, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLineBatchComponent", "DrawNewLine");

	Params::PhxLineBatchComponent_DrawNewLine Parms{};

	Parms.StartLocation = std::move(StartLocation);
	Parms.EndLocation = std::move(EndLocation);
	Parms.Color = std::move(Color);
	Parms.DepthPriority = DepthPriority;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_LockToGrabBone.OnCurrentMontageCompleted
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_LockToGrabBone::OnCurrentMontageCompleted(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_LockToGrabBone", "OnCurrentMontageCompleted");

	Params::PhxAbilityTask_LockToGrabBone_OnCurrentMontageCompleted Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_LockToGrabBone.OnNewMontageStarted
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_LockToGrabBone::OnNewMontageStarted(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_LockToGrabBone", "OnNewMontageStarted");

	Params::PhxAbilityTask_LockToGrabBone_OnNewMontageStarted Parms{};

	Parms.Montage = Montage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_LockToGrabBone.ReceiveNotify
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_LockToGrabBone::ReceiveNotify(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_LockToGrabBone", "ReceiveNotify");

	Params::PhxAbilityTask_LockToGrabBone_ReceiveNotify Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_RunAbility.OnAbilityFinished
// (Final, Native, Private)
// Parameters:
// const struct FGameplayTag&              InTag                                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_RunAbility::OnAbilityFinished(const struct FGameplayTag& InTag, int32 NewCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_RunAbility", "OnAbilityFinished");

	Params::PhxAbilityTask_RunAbility_OnAbilityFinished Parms{};

	Parms.InTag = std::move(InTag);
	Parms.NewCount = NewCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent.DeactivateWildCard
// (Final, Native, Public)

void UPhxAICharacterComponent::DeactivateWildCard()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent", "DeactivateWildCard");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent.OnReceivedDamage
// (Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterComponent::OnReceivedDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent", "OnReceivedDamage");

	Params::PhxAICharacterComponent_OnReceivedDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent.OnRecievedComboEnder
// (Native, Protected)
// Parameters:
// class APhxCharacter*                    Target                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxMeleeAttackDefinition*        ComboEndingAttack                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterComponent::OnRecievedComboEnder(class APhxCharacter* Target, class UPhxMeleeAttackDefinition* ComboEndingAttack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent", "OnRecievedComboEnder");

	Params::PhxAICharacterComponent_OnRecievedComboEnder Parms{};

	Parms.Target = Target;
	Parms.ComboEndingAttack = ComboEndingAttack;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlatformTexturePack.GetControllerKeyIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxControllerKeys                      InKey                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture* UPhxPlatformTexturePack::GetControllerKeyIcon(EPhxControllerKeys InKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlatformTexturePack", "GetControllerKeyIcon");

	Params::PhxPlatformTexturePack_GetControllerKeyIcon Parms{};

	Parms.InKey = InKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIHidingPoint.DisablePoint
// (Final, Native, Public, BlueprintCallable)

void APhxAIHidingPoint::DisablePoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHidingPoint", "DisablePoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIHidingPoint.EnablePoint
// (Final, Native, Public, BlueprintCallable)

void APhxAIHidingPoint::EnablePoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHidingPoint", "EnablePoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIHidingPoint.UpdateEditorPreview
// (Final, Native, Private)

void APhxAIHidingPoint::UpdateEditorPreview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIHidingPoint", "UpdateEditorPreview");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPerformanceProfilingActor.BeginPerformanceProfiling
// (Final, Exec, Native, Public, BlueprintCallable)

void APhxPerformanceProfilingActor::BeginPerformanceProfiling()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPerformanceProfilingActor", "BeginPerformanceProfiling");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPerformanceProfilingActor.EndPerformanceProfiling
// (Final, Exec, Native, Public, BlueprintCallable)

void APhxPerformanceProfilingActor::EndPerformanceProfiling()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPerformanceProfilingActor", "EndPerformanceProfiling");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPerformanceProfilingActor.LogPerformanceProfilingDataToFile
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    PerfIdentifier                                         (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPerformanceProfilingActor::LogPerformanceProfilingDataToFile(const class FString& PerfIdentifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPerformanceProfilingActor", "LogPerformanceProfilingDataToFile");

	Params::PhxPerformanceProfilingActor_LogPerformanceProfilingDataToFile Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPerformanceProfilingActor.SavePerformanceDataPoint
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Identifier                                             (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPerformanceProfilingActor::SavePerformanceDataPoint(const class FString& Identifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPerformanceProfilingActor", "SavePerformanceDataPoint");

	Params::PhxPerformanceProfilingActor_SavePerformanceDataPoint Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPerformanceProfilingActor.UpdatePerformanceProfiling
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPerformanceProfilingData        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FPerformanceProfilingData APhxPerformanceProfilingActor::UpdatePerformanceProfiling(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPerformanceProfilingActor", "UpdatePerformanceProfiling");

	Params::PhxPerformanceProfilingActor_UpdatePerformanceProfiling Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPerformanceProfilingActor.IsPerformanceProfilingPaused
// (Final, Exec, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPerformanceProfilingActor::IsPerformanceProfilingPaused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPerformanceProfilingActor", "IsPerformanceProfilingPaused");

	Params::PhxPerformanceProfilingActor_IsPerformanceProfilingPaused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProjectile.BP_OnHit
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxProjectile::BP_OnHit(class AActor* OtherActor, const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProjectile", "BP_OnHit");

	Params::PhxProjectile_BP_OnHit Parms{};

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

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


// Function Phoenix.PhxProjectile.BP_OnHitCompanion
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    CompanionCharacter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxProjectile::BP_OnHitCompanion(class APhxCharacter* CompanionCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProjectile", "BP_OnHitCompanion");

	Params::PhxProjectile_BP_OnHitCompanion Parms{};

	Parms.CompanionCharacter = CompanionCharacter;

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


// Function Phoenix.PhxProjectile.BP_OnHitEnemy
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    EnemyCharacter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxProjectile::BP_OnHitEnemy(class APhxCharacter* EnemyCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProjectile", "BP_OnHitEnemy");

	Params::PhxProjectile_BP_OnHitEnemy Parms{};

	Parms.EnemyCharacter = EnemyCharacter;

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


// Function Phoenix.PhxProjectile.BP_OnHitPlayer
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APhxPlayerCharacter*              PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxProjectile::BP_OnHitPlayer(class APhxPlayerCharacter* PlayerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProjectile", "BP_OnHitPlayer");

	Params::PhxProjectile_BP_OnHitPlayer Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

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


// Function Phoenix.PhxProjectile.HandleTakeAnyDamage
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxProjectile::HandleTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProjectile", "HandleTakeAnyDamage");

	Params::PhxProjectile_HandleTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProjectile.OnProjectileBounce
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   ImpactVelocity                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxProjectile::OnProjectileBounce(const struct FHitResult& ImpactResult, const struct FVector& ImpactVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProjectile", "OnProjectileBounce");

	Params::PhxProjectile_OnProjectileBounce Parms{};

	Parms.ImpactResult = std::move(ImpactResult);
	Parms.ImpactVelocity = std::move(ImpactVelocity);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProjectile.OnProjectileStop
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxProjectile::OnProjectileStop(const struct FHitResult& ImpactResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProjectile", "OnProjectileStop");

	Params::PhxProjectile_OnProjectileStop Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_TurnToFaceWorldPosition.CreateTurnToFaceWorldPositionTask
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldPosition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAbilityTask_TurnToFaceWorldPosition*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAbilityTask_TurnToFaceWorldPosition* UPhxAbilityTask_TurnToFaceWorldPosition::CreateTurnToFaceWorldPositionTask(class UGameplayAbility* OwningAbility, const struct FVector& WorldPosition, float Speed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAbilityTask_TurnToFaceWorldPosition", "CreateTurnToFaceWorldPositionTask");

	Params::PhxAbilityTask_TurnToFaceWorldPosition_CreateTurnToFaceWorldPositionTask Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.WorldPosition = std::move(WorldPosition);
	Parms.Speed = Speed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameplayAbility_LoopingMontageWithTransitions.OnAngleConditionMet
// (Final, Native, Private)
// Parameters:
// float                                   TimeActive                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_LoopingMontageWithTransitions::OnAngleConditionMet(float TimeActive, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_LoopingMontageWithTransitions", "OnAngleConditionMet");

	Params::PhxAIGameplayAbility_LoopingMontageWithTransitions_OnAngleConditionMet Parms{};

	Parms.TimeActive = TimeActive;
	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_LoopingMontageWithTransitions.OnTransitionCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_LoopingMontageWithTransitions::OnTransitionCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_LoopingMontageWithTransitions", "OnTransitionCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_LoopingMontageWithTransitions.OnTransitionRequested
// (Final, Native, Private)

void UPhxAIGameplayAbility_LoopingMontageWithTransitions::OnTransitionRequested()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_LoopingMontageWithTransitions", "OnTransitionRequested");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_LoopingMontageWithTransitions.ShouldTransitionLeft
// (Final, Native, Private)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIGameplayAbility_LoopingMontageWithTransitions::ShouldTransitionLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_LoopingMontageWithTransitions", "ShouldTransitionLeft");

	Params::PhxAIGameplayAbility_LoopingMontageWithTransitions_ShouldTransitionLeft Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldMarkerWidget.SetDistance
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWorldMarkerWidget::SetDistance(float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldMarkerWidget", "SetDistance");

	Params::PhxWorldMarkerWidget_SetDistance Parms{};

	Parms.Distance = Distance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_WaitComponentHit.CreateWaitComponentTask
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              ComponentToCheck                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEndAfterFirstHit                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAbilityTask_WaitComponentHit* ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAbilityTask_WaitComponentHit* UPhxAbilityTask_WaitComponentHit::CreateWaitComponentTask(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, class UPrimitiveComponent* ComponentToCheck, bool bEndAfterFirstHit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAbilityTask_WaitComponentHit", "CreateWaitComponentTask");

	Params::PhxAbilityTask_WaitComponentHit_CreateWaitComponentTask Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.ComponentToCheck = ComponentToCheck;
	Parms.bEndAfterFirstHit = bEndAfterFirstHit;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAbilityTask_WaitComponentHit.OnHitCallback
// (Final, Native, Private, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_WaitComponentHit", "OnHitCallback");

	Params::PhxAbilityTask_WaitComponentHit_OnHitCallback Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent_Parasite.HandleAIDied
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterComponent_Parasite::HandleAIDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Parasite", "HandleAIDied");

	Params::PhxAICharacterComponent_Parasite_HandleAIDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_WaitEarlyExitAllowed.ReceiveNotify
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_WaitEarlyExitAllowed::ReceiveNotify(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_WaitEarlyExitAllowed", "ReceiveNotify");

	Params::PhxAbilityTask_WaitEarlyExitAllowed_ReceiveNotify Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent_Dangler.HandleAIDied
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterComponent_Dangler::HandleAIDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Dangler", "HandleAIDied");

	Params::PhxAICharacterComponent_Dangler_HandleAIDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_WaitForDeath.OnDeath
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_WaitForDeath::OnDeath(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_WaitForDeath", "OnDeath");

	Params::PhxAbilityTask_WaitForDeath_OnDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_WaitForPhxAnimNotify.ReceiveNotify
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_WaitForPhxAnimNotify::ReceiveNotify(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_WaitForPhxAnimNotify", "ReceiveNotify");

	Params::PhxAbilityTask_WaitForPhxAnimNotify_ReceiveNotify Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_WaitForPhxAnimNotifyState.ReceiveNotifyStateBegin
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_WaitForPhxAnimNotifyState::ReceiveNotifyStateBegin(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_WaitForPhxAnimNotifyState", "ReceiveNotifyStateBegin");

	Params::PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateBegin Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAbilityTask_WaitForPhxAnimNotifyState.ReceiveNotifyStateEnd
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAbilityTask_WaitForPhxAnimNotifyState::ReceiveNotifyStateEnd(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAbilityTask_WaitForPhxAnimNotifyState", "ReceiveNotifyStateEnd");

	Params::PhxAbilityTask_WaitForPhxAnimNotifyState_ReceiveNotifyStateEnd Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent_Leon_Infected.ConsumeAlphaCall
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAICharacterComponent_Leon_Infected::ConsumeAlphaCall()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Leon_Infected", "ConsumeAlphaCall");

	Params::PhxAICharacterComponent_Leon_Infected_ConsumeAlphaCall Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacterComponent_Leon_Infected.OnBodyPartDied
// (Final, Native, Private, HasOutParams)
// Parameters:
// const TArray<EPhxBodyPartType>&         DestroyedBodyParts                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           InstigatorActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OwnerCharacter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterComponent_Leon_Infected::OnBodyPartDied(const TArray<EPhxBodyPartType>& DestroyedBodyParts, class AActor* InstigatorActor, class AActor* OwnerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Leon_Infected", "OnBodyPartDied");

	Params::PhxAICharacterComponent_Leon_Infected_OnBodyPartDied Parms{};

	Parms.DestroyedBodyParts = std::move(DestroyedBodyParts);
	Parms.InstigatorActor = InstigatorActor;
	Parms.OwnerCharacter = OwnerCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterDefinition.GetValidBlueprintVariationIndices
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftObjectPtr<class UPhxAICharacterVariantDefinition>&AttributeVariationDefinition                           (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<int32>                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<int32> UPhxAICharacterDefinition::GetValidBlueprintVariationIndices(const TSoftObjectPtr<class UPhxAICharacterVariantDefinition>& AttributeVariationDefinition) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterDefinition", "GetValidBlueprintVariationIndices");

	Params::PhxAICharacterDefinition_GetValidBlueprintVariationIndices Parms{};

	Parms.AttributeVariationDefinition = AttributeVariationDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacterComponent_Rusher.Cloak
// (Final, Native, Public, BlueprintCallable)

void UPhxAICharacterComponent_Rusher::Cloak()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Rusher", "Cloak");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent_Rusher.Uncloak
// (Final, Native, Public, BlueprintCallable)

void UPhxAICharacterComponent_Rusher::Uncloak()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Rusher", "Uncloak");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeaponSwitcher.CancelPressed
// (Event, Public, BlueprintEvent)

void UPhxWeaponSwitcher::CancelPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "CancelPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxWeaponSwitcher.ConfirmHeld
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   TimeHeld                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeaponSwitcher::ConfirmHeld(float TimeHeld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "ConfirmHeld");

	Params::PhxWeaponSwitcher_ConfirmHeld Parms{};

	Parms.TimeHeld = TimeHeld;

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


// Function Phoenix.PhxWeaponSwitcher.HandleDirectionInput
// (Event, Public, BlueprintEvent)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeaponSwitcher::HandleDirectionInput(EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "HandleDirectionInput");

	Params::PhxWeaponSwitcher_HandleDirectionInput Parms{};

	Parms.Direction = Direction;

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


// Function Phoenix.PhxWeaponSwitcher.OnSelectionChanged
// (Event, Public, BlueprintEvent)

void UPhxWeaponSwitcher::OnSelectionChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "OnSelectionChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxWeaponSwitcher.Refresh
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UPhxWeaponSwitcher::Refresh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "Refresh");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxWeaponSwitcher.SetCurrentSelected
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxWeaponSwitcherSlot*           WeaponSlot                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeaponSwitcher::SetCurrentSelected(class UPhxWeaponSwitcherSlot* WeaponSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "SetCurrentSelected");

	Params::PhxWeaponSwitcher_SetCurrentSelected Parms{};

	Parms.WeaponSlot = WeaponSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeaponSwitcher.GetCurrentSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxWeaponSwitcherSlot*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxWeaponSwitcherSlot* UPhxWeaponSwitcher::GetCurrentSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "GetCurrentSelected");

	Params::PhxWeaponSwitcher_GetCurrentSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWeaponSwitcher.IsConfirmPressAllowed
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxWeaponSwitcher::IsConfirmPressAllowed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSwitcher", "IsConfirmPressAllowed");

	Params::PhxWeaponSwitcher_IsConfirmPressAllowed Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSaveGameManager*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSaveGameManager* UPhxSaveGameManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSaveGameManager", "Get");

	Params::PhxSaveGameManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.AttemptAutoSave
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UPhxDifficultySettings*     DifficultySettings                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::AttemptAutoSave(const class UPhxDifficultySettings* DifficultySettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "AttemptAutoSave");

	Params::PhxSaveGameManager_AttemptAutoSave Parms{};

	Parms.DifficultySettings = DifficultySettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.BackupSaveFile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveFileInfo                                           (Parm, NativeAccessSpecifierPublic)
// ESDSUserCloudType                       CloudSaveTarget                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::BackupSaveFile(const struct FPhxSaveGameInfo& SaveFileInfo, ESDSUserCloudType CloudSaveTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "BackupSaveFile");

	Params::PhxSaveGameManager_BackupSaveFile Parms{};

	Parms.SaveFileInfo = std::move(SaveFileInfo);
	Parms.CloudSaveTarget = CloudSaveTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.CanCreateNewSaveFile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameManager::CanCreateNewSaveFile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "CanCreateNewSaveFile");

	Params::PhxSaveGameManager_CanCreateNewSaveFile Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.CreateNewSaveFile
// (Final, Native, Public, BlueprintCallable)

void UPhxSaveGameManager::CreateNewSaveFile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "CreateNewSaveFile");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.DebugLoadCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CheckpointId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::DebugLoadCheckpoint(class UWorld* WorldContext, const class FString& LevelName, const class FString& CheckpointId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "DebugLoadCheckpoint");

	Params::PhxSaveGameManager_DebugLoadCheckpoint Parms{};

	Parms.WorldContext = WorldContext;
	Parms.LevelName = std::move(LevelName);
	Parms.CheckpointId = std::move(CheckpointId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.DebugSaveCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CheckpointId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::DebugSaveCheckpoint(const class FString& LevelName, const class FString& CheckpointId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "DebugSaveCheckpoint");

	Params::PhxSaveGameManager_DebugSaveCheckpoint Parms{};

	Parms.LevelName = std::move(LevelName);
	Parms.CheckpointId = std::move(CheckpointId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.DeleteSaveFile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveToDelete                                           (Parm, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::DeleteSaveFile(const struct FPhxSaveGameInfo& SaveToDelete)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "DeleteSaveFile");

	Params::PhxSaveGameManager_DeleteSaveFile Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.LoadGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SaveSlot                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             UserIndex                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bLoadForNewGamePlus                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bTransfer                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::LoadGame(class UObject* WorldContext, const class FString& SaveSlot, const int32 UserIndex, const bool bLoadForNewGamePlus, const bool bTransfer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "LoadGame");

	Params::PhxSaveGameManager_LoadGame Parms{};

	Parms.WorldContext = WorldContext;
	Parms.SaveSlot = std::move(SaveSlot);
	Parms.UserIndex = UserIndex;
	Parms.bLoadForNewGamePlus = bLoadForNewGamePlus;
	Parms.bTransfer = bTransfer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.LoadGameIntoLevel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPhxSaveGameInfo&          SaveFile                                               (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     NewGameTypeTag                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class ULevelTransitionDataAsset>LevelToTransitionTo                                    (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             UserIndex                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bTransfer                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::LoadGameIntoLevel(class UObject* WorldContext, const struct FPhxSaveGameInfo& SaveFile, const struct FGameplayTagContainer& NewGameTypeTag, TSoftObjectPtr<class ULevelTransitionDataAsset> LevelToTransitionTo, const int32 UserIndex, const bool bTransfer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "LoadGameIntoLevel");

	Params::PhxSaveGameManager_LoadGameIntoLevel Parms{};

	Parms.WorldContext = WorldContext;
	Parms.SaveFile = std::move(SaveFile);
	Parms.NewGameTypeTag = std::move(NewGameTypeTag);
	Parms.LevelToTransitionTo = LevelToTransitionTo;
	Parms.UserIndex = UserIndex;
	Parms.bTransfer = bTransfer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.LoadSaveFile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPhxSaveGameInfo&          SaveFile                                               (Parm, NativeAccessSpecifierPublic)
// bool                                    bLoadForNewGamePlus                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::LoadSaveFile(class UObject* WorldContext, const struct FPhxSaveGameInfo& SaveFile, bool bLoadForNewGamePlus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "LoadSaveFile");

	Params::PhxSaveGameManager_LoadSaveFile Parms{};

	Parms.WorldContext = WorldContext;
	Parms.SaveFile = std::move(SaveFile);
	Parms.bLoadForNewGamePlus = bLoadForNewGamePlus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.OverwriteSaveFile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveToOverwrite                                        (Parm, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::OverwriteSaveFile(const struct FPhxSaveGameInfo& SaveToOverwrite)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "OverwriteSaveFile");

	Params::PhxSaveGameManager_OverwriteSaveFile Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.RefreshSaveInfoList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bRefreshCloudSaves                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::RefreshSaveInfoList(bool bRefreshCloudSaves)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "RefreshSaveInfoList");

	Params::PhxSaveGameManager_RefreshSaveInfoList Parms{};

	Parms.bRefreshCloudSaves = bRefreshCloudSaves;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.SaveGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SaveSlot                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             UserIndex                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bForceSave                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::SaveGame(const class FString& SaveSlot, const int32 UserIndex, const bool bForceSave)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "SaveGame");

	Params::PhxSaveGameManager_SaveGame Parms{};

	Parms.SaveSlot = std::move(SaveSlot);
	Parms.UserIndex = UserIndex;
	Parms.bForceSave = bForceSave;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.SubmitSaveGame
// (Final, Native, Protected)
// Parameters:
// const class FString&                    SaveSlot                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             UserIndex                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EPhxSaveGameType                  SaveType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bOverwritingExistingSave                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bForceSave                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSaveGameManager::SubmitSaveGame(const class FString& SaveSlot, const int32 UserIndex, const EPhxSaveGameType SaveType, const bool bOverwritingExistingSave, const bool bForceSave)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "SubmitSaveGame");

	Params::PhxSaveGameManager_SubmitSaveGame Parms{};

	Parms.SaveSlot = std::move(SaveSlot);
	Parms.UserIndex = UserIndex;
	Parms.SaveType = SaveType;
	Parms.bOverwritingExistingSave = bOverwritingExistingSave;
	Parms.bForceSave = bForceSave;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSaveGameManager.CanSaveGame
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameManager::CanSaveGame() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "CanSaveGame");

	Params::PhxSaveGameManager_CanSaveGame Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.CanWriteDebugSaveData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CheckpointId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameManager::CanWriteDebugSaveData(const class FString& LevelName, const class FString& CheckpointId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "CanWriteDebugSaveData");

	Params::PhxSaveGameManager_CanWriteDebugSaveData Parms{};

	Parms.LevelName = std::move(LevelName);
	Parms.CheckpointId = std::move(CheckpointId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.DoesDebugSaveCheckpointExist
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CheckpointId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameManager::DoesDebugSaveCheckpointExist(const class FString& LevelName, const class FString& CheckpointId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "DoesDebugSaveCheckpointExist");

	Params::PhxSaveGameManager_DoesDebugSaveCheckpointExist Parms{};

	Parms.LevelName = std::move(LevelName);
	Parms.CheckpointId = std::move(CheckpointId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetCachedSaveInfo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FPhxSaveGameInfo>   ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FPhxSaveGameInfo> UPhxSaveGameManager::GetCachedSaveInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetCachedSaveInfo");

	Params::PhxSaveGameManager_GetCachedSaveInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetCheckpointText
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UPhxSaveGameManager::GetCheckpointText(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetCheckpointText");

	Params::PhxSaveGameManager_GetCheckpointText Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetDebugSaveTimeStamp
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CheckpointId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxSaveGameManager::GetDebugSaveTimeStamp(const class FString& LevelName, const class FString& CheckpointId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetDebugSaveTimeStamp");

	Params::PhxSaveGameManager_GetDebugSaveTimeStamp Parms{};

	Parms.LevelName = std::move(LevelName);
	Parms.CheckpointId = std::move(CheckpointId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetDifficultyTag
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayTag UPhxSaveGameManager::GetDifficultyTag(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetDifficultyTag");

	Params::PhxSaveGameManager_GetDifficultyTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetDifficultyText
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UPhxSaveGameManager::GetDifficultyText(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetDifficultyText");

	Params::PhxSaveGameManager_GetDifficultyText Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetIsGameMainStoryComplete
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameManager::GetIsGameMainStoryComplete(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetIsGameMainStoryComplete");

	Params::PhxSaveGameManager_GetIsGameMainStoryComplete Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetIsGameNGPlus
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameManager::GetIsGameNGPlus(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetIsGameNGPlus");

	Params::PhxSaveGameManager_GetIsGameNGPlus Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetIsGameStoryDLC
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSaveGameManager::GetIsGameStoryDLC(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetIsGameStoryDLC");

	Params::PhxSaveGameManager_GetIsGameStoryDLC Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetLastSaveSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxSaveGameManager::GetLastSaveSlot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetLastSaveSlot");

	Params::PhxSaveGameManager_GetLastSaveSlot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetLevelNameText
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UPhxSaveGameManager::GetLevelNameText(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetLevelNameText");

	Params::PhxSaveGameManager_GetLevelNameText Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetNewSaveInfo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FPhxSaveGameInfo                 ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FPhxSaveGameInfo UPhxSaveGameManager::GetNewSaveInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetNewSaveInfo");

	Params::PhxSaveGameManager_GetNewSaveInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSaveGameManager.GetObjectiveText
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPhxSaveGameInfo&          SaveInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UPhxSaveGameManager::GetObjectiveText(const struct FPhxSaveGameInfo& SaveInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSaveGameManager", "GetObjectiveText");

	Params::PhxSaveGameManager_GetObjectiveText Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootProp_Item.GetItemCost
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxRiotModeLootProp_Item::GetItemCost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Item", "GetItemCost");

	Params::PhxRiotModeLootProp_Item_GetItemCost Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootProp_Item.SetItemCost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Cost                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxRiotModeLootProp_Item::SetItemCost(int32 Cost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Item", "SetItemCost");

	Params::PhxRiotModeLootProp_Item_SetItemCost Parms{};

	Parms.Cost = Cost;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMeleeWeaponSettings.GetMeleeSpec
// (Final, Native, Public, Const)
// Parameters:
// const struct FMeleeWeaponSettings       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FMeleeWeaponSettings UPhxMeleeWeaponSettings::GetMeleeSpec() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMeleeWeaponSettings", "GetMeleeSpec");

	Params::PhxMeleeWeaponSettings_GetMeleeSpec Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerTriggerBox.HandleActorBeginOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerTriggerBox::HandleActorBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerTriggerBox", "HandleActorBeginOverlap");

	Params::PhxPlayerTriggerBox_HandleActorBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerTriggerBox.HandleActorEndOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerTriggerBox::HandleActorEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerTriggerBox", "HandleActorEndOverlap");

	Params::PhxPlayerTriggerBox_HandleActorEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterMovementComponent.OnMontageBlendingOut
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     InMontage                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInInterrupted                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterMovementComponent::OnMontageBlendingOut(class UAnimMontage* InMontage, bool bInInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterMovementComponent", "OnMontageBlendingOut");

	Params::PhxCharacterMovementComponent_OnMontageBlendingOut Parms{};

	Parms.InMontage = InMontage;
	Parms.bInInterrupted = bInInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterMovementComponent.OnMontageEnded
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     InMontage                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInInterrupted                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterMovementComponent::OnMontageEnded(class UAnimMontage* InMontage, bool bInInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterMovementComponent", "OnMontageEnded");

	Params::PhxCharacterMovementComponent_OnMontageEnded Parms{};

	Parms.InMontage = InMontage;
	Parms.bInInterrupted = bInInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterMovementComponent.OnMontageStarted
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     InMontage                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterMovementComponent::OnMontageStarted(class UAnimMontage* InMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterMovementComponent", "OnMontageStarted");

	Params::PhxCharacterMovementComponent_OnMontageStarted Parms{};

	Parms.InMontage = InMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIMovementComponent.OnBumpingCapsuleBeginOverlap
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxAIMovementComponent::OnBumpingCapsuleBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIMovementComponent", "OnBumpingCapsuleBeginOverlap");

	Params::PhxAIMovementComponent_OnBumpingCapsuleBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventCharacter.RequestPositionSyncingWithScriptedEvent
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APhxScriptedEventActor*           ScriptedEvent                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      BindingTag                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxScriptedEventCharacter::RequestPositionSyncingWithScriptedEvent(class APhxScriptedEventActor* ScriptedEvent, const class FName& BindingTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventCharacter", "RequestPositionSyncingWithScriptedEvent");

	Params::PhxScriptedEventCharacter_RequestPositionSyncingWithScriptedEvent Parms{};

	Parms.ScriptedEvent = ScriptedEvent;
	Parms.BindingTag = BindingTag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetGroupWidget.SetDetailTimingVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Vis                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetGroupWidget::SetDetailTimingVisibility(ESlateVisibility Vis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetGroupWidget", "SetDetailTimingVisibility");

	Params::PhxAssetBudgetGroupWidget_SetDetailTimingVisibility Parms{};

	Parms.Vis = Vis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetGroupWidget.SetDrawsStatsVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Vis                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetGroupWidget::SetDrawsStatsVisibility(ESlateVisibility Vis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetGroupWidget", "SetDrawsStatsVisibility");

	Params::PhxAssetBudgetGroupWidget_SetDrawsStatsVisibility Parms{};

	Parms.Vis = Vis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.PrintAchievements
// (Final, Native, Static, Protected)
// Parameters:
// bool                                    bResult                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class USDSAchievement*>&   Achievements                                           (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::PrintAchievements(bool bResult, const TArray<class USDSAchievement*>& Achievements)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAchievementsManager", "PrintAchievements");

	Params::PhxAchievementsManager_PrintAchievements Parms{};

	Parms.bResult = bResult;
	Parms.Achievements = std::move(Achievements);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.OnDefensiveAction
// (Final, Native, Protected, HasOutParams)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::OnDefensiveAction(EReactionType ReactionType, EDefensiveReactDirection ReactionDir, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAchievementsManager", "OnDefensiveAction");

	Params::PhxAchievementsManager_OnDefensiveAction Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.OnEnemyBodyPartDead
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EPhxBodyPartType>&         KilledParts                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           InstigatorActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::OnEnemyBodyPartDead(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, const TArray<EPhxBodyPartType>& KilledParts, class AActor* InstigatorActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAchievementsManager", "OnEnemyBodyPartDead");

	Params::PhxAchievementsManager_OnEnemyBodyPartDead Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.KilledParts = std::move(KilledParts);
	Parms.InstigatorActor = InstigatorActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.OnEnemyDeath
// (Final, Native, Protected)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::OnEnemyDeath(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAchievementsManager", "OnEnemyDeath");

	Params::PhxAchievementsManager_OnEnemyDeath Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.OnEnemyGRPGrabbed
// (Final, Native, Protected)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::OnEnemyGRPGrabbed(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAchievementsManager", "OnEnemyGRPGrabbed");

	Params::PhxAchievementsManager_OnEnemyGRPGrabbed Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.OnEnemyKilledByHazard
// (Final, Native, Protected)
// Parameters:
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEnvironmentalHazard*             HazardActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::OnEnemyKilledByHazard(class APhxAICharacter* Enemy, class AEnvironmentalHazard* HazardActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAchievementsManager", "OnEnemyKilledByHazard");

	Params::PhxAchievementsManager_OnEnemyKilledByHazard Parms{};

	Parms.Enemy = Enemy;
	Parms.HazardActor = HazardActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.OnEnemyKilledByMeleeWeapon
// (Final, Native, Protected)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AMeleeWeapon*                     Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxMeleeAttackDefinition*        AttackDef                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::OnEnemyKilledByMeleeWeapon(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, class AMeleeWeapon* Weapon, class UPhxMeleeAttackDefinition* AttackDef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAchievementsManager", "OnEnemyKilledByMeleeWeapon");

	Params::PhxAchievementsManager_OnEnemyKilledByMeleeWeapon Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.Weapon = Weapon;
	Parms.AttackDef = AttackDef;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAchievementsManager.OnPlayerDeath
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAchievementsManager::OnPlayerDeath(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAchievementsManager", "OnPlayerDeath");

	Params::PhxAchievementsManager_OnPlayerDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAcousticPortalComponent.OnOverlapBegin
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxAcousticPortalComponent::OnOverlapBegin(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAcousticPortalComponent", "OnOverlapBegin");

	Params::PhxAcousticPortalComponent_OnOverlapBegin Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAcousticPortalComponent.OnOverlapEnd
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAcousticPortalComponent::OnOverlapEnd(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAcousticPortalComponent", "OnOverlapEnd");

	Params::PhxAcousticPortalComponent_OnOverlapEnd Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAcousticPortalComponent.ScaleToPercent
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// float                                   TargetPercent                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeToOpen                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAcousticPortalComponent::ScaleToPercent(float TargetPercent, float TimeToOpen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAcousticPortalComponent", "ScaleToPercent");

	Params::PhxAcousticPortalComponent_ScaleToPercent Parms{};

	Parms.TargetPercent = TargetPercent;
	Parms.TimeToOpen = TimeToOpen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIAbilityTask_DefaultAttack.HandleAnimNotifyReceived
// (Final, Native, Private)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIAbilityTask_DefaultAttack::HandleAnimNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIAbilityTask_DefaultAttack", "HandleAnimNotifyReceived");

	Params::PhxAIAbilityTask_DefaultAttack_HandleAnimNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIVirus.BP_OnOwningCharacterDisableRagdoll
// (Event, Public, BlueprintEvent)

void APhxAIVirus::BP_OnOwningCharacterDisableRagdoll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "BP_OnOwningCharacterDisableRagdoll");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAIVirus.BP_OnRangedWeaponAimedAt
// (Event, Public, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    AimingCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIVirus::BP_OnRangedWeaponAimedAt(class APhxCharacter* AimingCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "BP_OnRangedWeaponAimedAt");

	Params::PhxAIVirus_BP_OnRangedWeaponAimedAt Parms{};

	Parms.AimingCharacter = AimingCharacter;

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


// Function Phoenix.PhxAIVirus.BP_OnRangedWeaponAimedAway
// (Event, Public, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    AimingCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIVirus::BP_OnRangedWeaponAimedAway(class APhxCharacter* AimingCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "BP_OnRangedWeaponAimedAway");

	Params::PhxAIVirus_BP_OnRangedWeaponAimedAway Parms{};

	Parms.AimingCharacter = AimingCharacter;

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


// Function Phoenix.PhxAIVirus.OnKillAnimCompleted
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIVirus::OnKillAnimCompleted(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "OnKillAnimCompleted");

	Params::PhxAIVirus_OnKillAnimCompleted Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIVirus.OnOwningCharacterDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIVirus::OnOwningCharacterDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "OnOwningCharacterDestroyed");

	Params::PhxAIVirus_OnOwningCharacterDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIVirus.OnOwningCharacterHidden
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIVirus::OnOwningCharacterHidden(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "OnOwningCharacterHidden");

	Params::PhxAIVirus_OnOwningCharacterHidden Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIVirus.OnOwningCharacterUnhidden
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIVirus::OnOwningCharacterUnhidden(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "OnOwningCharacterUnhidden");

	Params::PhxAIVirus_OnOwningCharacterUnhidden Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIVirus.OnRetractAnimCompleted
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIVirus::OnRetractAnimCompleted(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIVirus", "OnRetractAnimCompleted");

	Params::PhxAIVirus_OnRetractAnimCompleted Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutomationBlueprintFunctionLibrary.InputAxis
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             ActionName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Delta                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             DeltaTime                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             NumSamples                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAutomationBlueprintFunctionLibrary::InputAxis(class FName ActionName, const float Delta, const float DeltaTime, const int32 NumSamples)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAutomationBlueprintFunctionLibrary", "InputAxis");

	Params::PhxAutomationBlueprintFunctionLibrary_InputAxis Parms{};

	Parms.ActionName = ActionName;
	Parms.Delta = Delta;
	Parms.DeltaTime = DeltaTime;
	Parms.NumSamples = NumSamples;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutomationBlueprintFunctionLibrary.InputKey
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      ActionName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputEvent                       InputEvent                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             AmountDepressed                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAutomationBlueprintFunctionLibrary::InputKey(const class FName& ActionName, const EInputEvent InputEvent, const float AmountDepressed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAutomationBlueprintFunctionLibrary", "InputKey");

	Params::PhxAutomationBlueprintFunctionLibrary_InputKey Parms{};

	Parms.ActionName = ActionName;
	Parms.InputEvent = InputEvent;
	Parms.AmountDepressed = AmountDepressed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAutomationBlueprintFunctionLibrary.TeleportPlayerToLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UPhxAutomationBlueprintFunctionLibrary::TeleportPlayerToLocation(const struct FVector& Location, const struct FRotator& Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAutomationBlueprintFunctionLibrary", "TeleportPlayerToLocation");

	Params::PhxAutomationBlueprintFunctionLibrary_TeleportPlayerToLocation Parms{};

	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAudioSystem*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAudioSystem* UPhxAudioSystem::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioSystem", "Get");

	Params::PhxAudioSystem_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAudioSystem.GetRoomAndPortalVisibility
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAudioSystem::GetRoomAndPortalVisibility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioSystem", "GetRoomAndPortalVisibility");

	Params::PhxAudioSystem_GetRoomAndPortalVisibility Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAudioSystem.GetRTPC
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAkRtpc*                          RTPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     SoundComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxAudioSystem::GetRTPC(class UAkRtpc* RTPC, class UAkComponent* SoundComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioSystem", "GetRTPC");

	Params::PhxAudioSystem_GetRTPC Parms{};

	Parms.RTPC = RTPC;
	Parms.SoundComp = SoundComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAudioSystem.SetDialogueLanguage
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Language                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetDialogueLanguage(const class FString& Language)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioSystem", "SetDialogueLanguage");

	Params::PhxAudioSystem_SetDialogueLanguage Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetMuted
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    Muted                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetMuted(bool Muted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioSystem", "SetMuted");

	Params::PhxAudioSystem_SetMuted Parms{};

	Parms.Muted = Muted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetRoomAndPortalVisibility
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetRoomAndPortalVisibility(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioSystem", "SetRoomAndPortalVisibility");

	Params::PhxAudioSystem_SetRoomAndPortalVisibility Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetRTPC
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAkRtpc*                          RTPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RTPCValue                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     SoundComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetRTPC(class UAkRtpc* RTPC, float RTPCValue, class UAkComponent* SoundComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioSystem", "SetRTPC");

	Params::PhxAudioSystem_SetRTPC Parms{};

	Parms.RTPC = RTPC;
	Parms.RTPCValue = RTPCValue;
	Parms.SoundComp = SoundComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.GetPlayerRadioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   MinOutValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxOutValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxAudioSystem::GetPlayerRadioVolume(float MinOutValue, float MaxOutValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "GetPlayerRadioVolume");

	Params::PhxAudioSystem_GetPlayerRadioVolume Parms{};

	Parms.MinOutValue = MinOutValue;
	Parms.MaxOutValue = MaxOutValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAudioSystem.OnInputTypeChanged
// (Final, Native, Private)

void UPhxAudioSystem::OnInputTypeChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "OnInputTypeChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.OnRumbleEnabled
// (Final, Native, Private)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::OnRumbleEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "OnRumbleEnabled");

	Params::PhxAudioSystem_OnRumbleEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.PostGlobalEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::PostGlobalEvent(class UAkAudioEvent* Event)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "PostGlobalEvent");

	Params::PhxAudioSystem_PostGlobalEvent Parms{};

	Parms.Event = Event;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetAkGeoEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetAkGeoEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetAkGeoEnabled");

	Params::PhxAudioSystem_SetAkGeoEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetDialogueEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetDialogueEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetDialogueEnabled");

	Params::PhxAudioSystem_SetDialogueEnabled Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetDialogueVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetDialogueVolume(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetDialogueVolume");

	Params::PhxAudioSystem_SetDialogueVolume Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetMusicEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetMusicEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetMusicEnabled");

	Params::PhxAudioSystem_SetMusicEnabled Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetMusicVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetMusicVolume(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetMusicVolume");

	Params::PhxAudioSystem_SetMusicVolume Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetOnScreenDebugging
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetOnScreenDebugging(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetOnScreenDebugging");

	Params::PhxAudioSystem_SetOnScreenDebugging Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetRadioBanterChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxRadioBanterChannel                  Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetRadioBanterChannel(EPhxRadioBanterChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetRadioBanterChannel");

	Params::PhxAudioSystem_SetRadioBanterChannel Parms{};

	Parms.Channel = Channel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetRadioBanterVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetRadioBanterVolume(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetRadioBanterVolume");

	Params::PhxAudioSystem_SetRadioBanterVolume Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetSFXEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetSFXEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetSFXEnabled");

	Params::PhxAudioSystem_SetSFXEnabled Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioSystem.SetSFXVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAudioSystem::SetSFXVolume(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAudioSystem", "SetSFXVolume");

	Params::PhxAudioSystem_SetSFXVolume Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.DoScriptedAction
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              ActionTag                                              (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OptionalTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_DoScriptedAction*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_DoScriptedAction* UPhxAIBlueprintAction_DoScriptedAction::DoScriptedAction(const struct FGameplayTag& ActionTag, class APhxAICharacter* Character, class AActor* OptionalTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_DoScriptedAction", "DoScriptedAction");

	Params::PhxAIBlueprintAction_DoScriptedAction_DoScriptedAction Parms{};

	Parms.ActionTag = std::move(ActionTag);
	Parms.Character = Character;
	Parms.OptionalTarget = OptionalTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.HandleScriptedActionBegin
// (Final, Native, Private)
// Parameters:
// const struct FGameplayTag&              ActionTag                                              (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OptionalTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_DoScriptedAction::HandleScriptedActionBegin(const struct FGameplayTag& ActionTag, class APhxAICharacter* Character, class AActor* OptionalTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_DoScriptedAction", "HandleScriptedActionBegin");

	Params::PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionBegin Parms{};

	Parms.ActionTag = std::move(ActionTag);
	Parms.Character = Character;
	Parms.OptionalTarget = OptionalTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.HandleScriptedActionCompleted
// (Final, Native, Private)
// Parameters:
// const struct FGameplayTag&              ActionTag                                              (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OptionalTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_DoScriptedAction::HandleScriptedActionCompleted(const struct FGameplayTag& ActionTag, class APhxAICharacter* Character, class AActor* OptionalTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_DoScriptedAction", "HandleScriptedActionCompleted");

	Params::PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionCompleted Parms{};

	Parms.ActionTag = std::move(ActionTag);
	Parms.Character = Character;
	Parms.OptionalTarget = OptionalTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_DoScriptedAction.HandleScriptedActionFailed
// (Final, Native, Private)
// Parameters:
// const struct FGameplayTag&              ActionTag                                              (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OptionalTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_DoScriptedAction::HandleScriptedActionFailed(const struct FGameplayTag& ActionTag, class APhxAICharacter* Character, class AActor* OptionalTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_DoScriptedAction", "HandleScriptedActionFailed");

	Params::PhxAIBlueprintAction_DoScriptedAction_HandleScriptedActionFailed Parms{};

	Parms.ActionTag = std::move(ActionTag);
	Parms.Character = Character;
	Parms.OptionalTarget = OptionalTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterEncounterNetwork
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetwork*           EncounterNetwork                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDespawnAfterEntering                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIMotionType                        MotionType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_EnterEncounterNetwork*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_EnterEncounterNetwork* UPhxAIBlueprintAction_EnterEncounterNetwork::EnterEncounterNetwork(class APhxAICharacter* Character, class APhxAIEncounterNetwork* EncounterNetwork, bool bDespawnAfterEntering, EPhxAIMotionType MotionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EnterEncounterNetwork", "EnterEncounterNetwork");

	Params::PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetwork Parms{};

	Parms.Character = Character;
	Parms.EncounterNetwork = EncounterNetwork;
	Parms.bDespawnAfterEntering = bDespawnAfterEntering;
	Parms.MotionType = MotionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterEncounterNetworkAtNode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetworkTraversalNode*Entrance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDespawnAfterEntering                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIMotionType                        MotionType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_EnterEncounterNetwork*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_EnterEncounterNetwork* UPhxAIBlueprintAction_EnterEncounterNetwork::EnterEncounterNetworkAtNode(class APhxAICharacter* Character, class APhxAIEncounterNetworkTraversalNode* Entrance, bool bDespawnAfterEntering, EPhxAIMotionType MotionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EnterEncounterNetwork", "EnterEncounterNetworkAtNode");

	Params::PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkAtNode Parms{};

	Parms.Character = Character;
	Parms.Entrance = Entrance;
	Parms.bDespawnAfterEntering = bDespawnAfterEntering;
	Parms.MotionType = MotionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterEncounterNetworkGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class UPhxAICharacterDefinition>AICharacterDefinition                                  (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetwork*           EncounterNetwork                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDespawnAfterEntering                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIMotionType                        MotionType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OverrideMaximumEntranceDistance                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_EnterEncounterNetwork::EnterEncounterNetworkGroup(class APhxAIEncounterGroup* EncounterGroup, TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition, class APhxAIEncounterNetwork* EncounterNetwork, bool bDespawnAfterEntering, EPhxAIMotionType MotionType, float OverrideMaximumEntranceDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EnterEncounterNetwork", "EnterEncounterNetworkGroup");

	Params::PhxAIBlueprintAction_EnterEncounterNetwork_EnterEncounterNetworkGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.AICharacterDefinition = AICharacterDefinition;
	Parms.EncounterNetwork = EncounterNetwork;
	Parms.bDespawnAfterEntering = bDespawnAfterEntering;
	Parms.MotionType = MotionType;
	Parms.OverrideMaximumEntranceDistance = OverrideMaximumEntranceDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterNearestEncounterNetwork
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDespawnAfterEntering                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIMotionType                        MotionType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_EnterEncounterNetwork*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_EnterEncounterNetwork* UPhxAIBlueprintAction_EnterEncounterNetwork::EnterNearestEncounterNetwork(class APhxAICharacter* Character, bool bDespawnAfterEntering, EPhxAIMotionType MotionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EnterEncounterNetwork", "EnterNearestEncounterNetwork");

	Params::PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetwork Parms{};

	Parms.Character = Character;
	Parms.bDespawnAfterEntering = bDespawnAfterEntering;
	Parms.MotionType = MotionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.EnterNearestEncounterNetworkGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class UPhxAICharacterDefinition>AICharacterDefinition                                  (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDespawnAfterEntering                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIMotionType                        MotionType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_EnterEncounterNetwork::EnterNearestEncounterNetworkGroup(class APhxAIEncounterGroup* EncounterGroup, TSoftObjectPtr<class UPhxAICharacterDefinition> AICharacterDefinition, bool bDespawnAfterEntering, EPhxAIMotionType MotionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_EnterEncounterNetwork", "EnterNearestEncounterNetworkGroup");

	Params::PhxAIBlueprintAction_EnterEncounterNetwork_EnterNearestEncounterNetworkGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.AICharacterDefinition = AICharacterDefinition;
	Parms.bDespawnAfterEntering = bDespawnAfterEntering;
	Parms.MotionType = MotionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_EnterEncounterNetwork.HandleEnterEncounterNetworkCompleted
// (Final, Native, Private)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_EnterEncounterNetwork::HandleEnterEncounterNetworkCompleted(bool bSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_EnterEncounterNetwork", "HandleEnterEncounterNetworkCompleted");

	Params::PhxAIBlueprintAction_EnterEncounterNetwork_HandleEnterEncounterNetworkCompleted Parms{};

	Parms.bSuccess = bSuccess;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_MoveWithinEncounterNetwork.MoveBetweenInternalEncounterNetworkNodes
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetworkWaypointNode*FromNode                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetworkWaypointNode*ToNode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_MoveWithinEncounterNetwork*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_MoveWithinEncounterNetwork* UPhxAIBlueprintAction_MoveWithinEncounterNetwork::MoveBetweenInternalEncounterNetworkNodes(class APhxAICharacter* Character, class APhxAIEncounterNetworkWaypointNode* FromNode, class APhxAIEncounterNetworkWaypointNode* ToNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_MoveWithinEncounterNetwork", "MoveBetweenInternalEncounterNetworkNodes");

	Params::PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveBetweenInternalEncounterNetworkNodes Parms{};

	Parms.Character = Character;
	Parms.FromNode = FromNode;
	Parms.ToNode = ToNode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_MoveWithinEncounterNetwork.MoveToInternalEncounterNetworkNode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIEncounterNetworkWaypointNode*Node                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_MoveWithinEncounterNetwork*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_MoveWithinEncounterNetwork* UPhxAIBlueprintAction_MoveWithinEncounterNetwork::MoveToInternalEncounterNetworkNode(class APhxAICharacter* Character, class APhxAIEncounterNetworkWaypointNode* Node)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_MoveWithinEncounterNetwork", "MoveToInternalEncounterNetworkNode");

	Params::PhxAIBlueprintAction_MoveWithinEncounterNetwork_MoveToInternalEncounterNetworkNode Parms{};

	Parms.Character = Character;
	Parms.Node = Node;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_MoveWithinEncounterNetwork.HandleMoveWithinEncounterNetworkCompleted
// (Final, Native, Private)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_MoveWithinEncounterNetwork::HandleMoveWithinEncounterNetworkCompleted(bool bSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_MoveWithinEncounterNetwork", "HandleMoveWithinEncounterNetworkCompleted");

	Params::PhxAIBlueprintAction_MoveWithinEncounterNetwork_HandleMoveWithinEncounterNetworkCompleted Parms{};

	Parms.bSuccess = bSuccess;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintAction_UsePatrol.LeadPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIPatrol*                     Patrol                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionLeadDefinition*LeadDefinition_0                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionWaitDefinition*LeadWaitDefinition_0                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionWaitDefinition*BacktrackWaitDefinition_0                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_UsePatrol*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_UsePatrol* UPhxAIBlueprintAction_UsePatrol::LeadPlayer(class APhxAICharacter* Character, class APhxAIPatrol* Patrol, const class UPhxAICompanionLeadDefinition* LeadDefinition_0, const class UPhxAICompanionWaitDefinition* LeadWaitDefinition_0, const class UPhxAICompanionWaitDefinition* BacktrackWaitDefinition_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_UsePatrol", "LeadPlayer");

	Params::PhxAIBlueprintAction_UsePatrol_LeadPlayer Parms{};

	Parms.Character = Character;
	Parms.Patrol = Patrol;
	Parms.LeadDefinition_0 = LeadDefinition_0;
	Parms.LeadWaitDefinition_0 = LeadWaitDefinition_0;
	Parms.BacktrackWaitDefinition_0 = BacktrackWaitDefinition_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_UsePatrol.UsePatrol
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIPatrol*                     Patrol                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIBlueprintAction_UsePatrol*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIBlueprintAction_UsePatrol* UPhxAIBlueprintAction_UsePatrol::UsePatrol(class APhxAICharacter* Character, class APhxAIPatrol* Patrol)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintAction_UsePatrol", "UsePatrol");

	Params::PhxAIBlueprintAction_UsePatrol_UsePatrol Parms{};

	Parms.Character = Character;
	Parms.Patrol = Patrol;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintAction_UsePatrol.HandlePatrolDeparted
// (Final, Native, Private)
// Parameters:
// class APhxAICharacter*                  Occupier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAIPatrol*                     Patrol                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintAction_UsePatrol::HandlePatrolDeparted(class APhxAICharacter* Occupier, class APhxAIPatrol* Patrol, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIBlueprintAction_UsePatrol", "HandlePatrolDeparted");

	Params::PhxAIBlueprintAction_UsePatrol_HandlePatrolDeparted Parms{};

	Parms.Occupier = Occupier;
	Parms.Patrol = Patrol;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.ClearOverrideCompanionChatterSet
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::ClearOverrideCompanionChatterSet(class APhxAICharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "ClearOverrideCompanionChatterSet");

	Params::PhxAIBlueprintLibrary_ClearOverrideCompanionChatterSet Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.ClearOverrideCompanionFidgetSet
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::ClearOverrideCompanionFidgetSet(class APhxAICharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "ClearOverrideCompanionFidgetSet");

	Params::PhxAIBlueprintLibrary_ClearOverrideCompanionFidgetSet Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.ClearWalkWithPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::ClearWalkWithPlayer(class APhxAICharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "ClearWalkWithPlayer");

	Params::PhxAIBlueprintLibrary_ClearWalkWithPlayer Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.DoAttackScriptedAction
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              AttackActionTag                                        (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::DoAttackScriptedAction(const struct FGameplayTag& AttackActionTag, class APhxAICharacter* Character, class AActor* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "DoAttackScriptedAction");

	Params::PhxAIBlueprintLibrary_DoAttackScriptedAction Parms{};

	Parms.AttackActionTag = std::move(AttackActionTag);
	Parms.Character = Character;
	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.DoScriptedAction
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              ActionTag                                              (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OptionalTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::DoScriptedAction(const struct FGameplayTag& ActionTag, class APhxAICharacter* Character, class AActor* OptionalTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "DoScriptedAction");

	Params::PhxAIBlueprintLibrary_DoScriptedAction Parms{};

	Parms.ActionTag = std::move(ActionTag);
	Parms.Character = Character;
	Parms.OptionalTarget = OptionalTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.FindNearestAliveAI
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacter* UPhxAIBlueprintLibrary::FindNearestAliveAI(class AActor* Source)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "FindNearestAliveAI");

	Params::PhxAIBlueprintLibrary_FindNearestAliveAI Parms{};

	Parms.Source = Source;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.FindNearestAliveAIToPlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacter* UPhxAIBlueprintLibrary::FindNearestAliveAIToPlayer(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "FindNearestAliveAIToPlayer");

	Params::PhxAIBlueprintLibrary_FindNearestAliveAIToPlayer Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.FollowPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionFollowDefinition*FollowDefinition                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionWaitDefinition*WaitDefinition                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::FollowPlayer(class APhxAICharacter* Character, const class UPhxAICompanionFollowDefinition* FollowDefinition, const class UPhxAICompanionWaitDefinition* WaitDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "FollowPlayer");

	Params::PhxAIBlueprintLibrary_FollowPlayer Parms{};

	Parms.Character = Character;
	Parms.FollowDefinition = FollowDefinition;
	Parms.WaitDefinition = WaitDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.ForceWalkWithPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::ForceWalkWithPlayer(class APhxAICharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "ForceWalkWithPlayer");

	Params::PhxAIBlueprintLibrary_ForceWalkWithPlayer Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetActiveCompanion
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APhxAICharacter*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacter* UPhxAIBlueprintLibrary::GetActiveCompanion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetActiveCompanion");

	Params::PhxAIBlueprintLibrary_GetActiveCompanion Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetAIGameStateManager
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIGameStateManager*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIGameStateManager* UPhxAIBlueprintLibrary::GetAIGameStateManager(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetAIGameStateManager");

	Params::PhxAIBlueprintLibrary_GetAIGameStateManager Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetAIOffensiveActionsComponent
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APhxAICharacterController*        AIController                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIOffensiveActionsComponent*  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAIOffensiveActionsComponent* UPhxAIBlueprintLibrary::GetAIOffensiveActionsComponent(class APhxAICharacterController* AIController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetAIOffensiveActionsComponent");

	Params::PhxAIBlueprintLibrary_GetAIOffensiveActionsComponent Parms{};

	Parms.AIController = AIController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetAwarenessLevelOfActor
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TestActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIAwarenessLevel                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxAIAwarenessLevel UPhxAIBlueprintLibrary::GetAwarenessLevelOfActor(class UObject* WorldContext, class AActor* Actor, class AActor* TestActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetAwarenessLevelOfActor");

	Params::PhxAIBlueprintLibrary_GetAwarenessLevelOfActor Parms{};

	Parms.WorldContext = WorldContext;
	Parms.Actor = Actor;
	Parms.TestActor = TestActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetLastKnowLocationOfActor
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TestActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPhxAIBlueprintLibrary::GetLastKnowLocationOfActor(class UObject* WorldContext, class AActor* Actor, class AActor* TestActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetLastKnowLocationOfActor");

	Params::PhxAIBlueprintLibrary_GetLastKnowLocationOfActor Parms{};

	Parms.WorldContext = WorldContext;
	Parms.Actor = Actor;
	Parms.TestActor = TestActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetPhxAICharacterController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           ControlledActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacterController*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacterController* UPhxAIBlueprintLibrary::GetPhxAICharacterController(class AActor* ControlledActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetPhxAICharacterController");

	Params::PhxAIBlueprintLibrary_GetPhxAICharacterController Parms{};

	Parms.ControlledActor = ControlledActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetPlayerFocusTarget
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UPhxAIBlueprintLibrary::GetPlayerFocusTarget(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetPlayerFocusTarget");

	Params::PhxAIBlueprintLibrary_GetPlayerFocusTarget Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetSelectedTargetActor
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APhxAICharacterController*        AIController                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UPhxAIBlueprintLibrary::GetSelectedTargetActor(class APhxAICharacterController* AIController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetSelectedTargetActor");

	Params::PhxAIBlueprintLibrary_GetSelectedTargetActor Parms{};

	Parms.AIController = AIController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.GetTimeAsPlayerFocusTarget
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxAIBlueprintLibrary::GetTimeAsPlayerFocusTarget(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "GetTimeAsPlayerFocusTarget");

	Params::PhxAIBlueprintLibrary_GetTimeAsPlayerFocusTarget Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.IsVisibleToPlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIBlueprintLibrary::IsVisibleToPlayer(class UObject* WorldContext, class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "IsVisibleToPlayer");

	Params::PhxAIBlueprintLibrary_IsVisibleToPlayer Parms{};

	Parms.WorldContext = WorldContext;
	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIBlueprintLibrary.LoadAI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAISpawner_Character*          Spawner                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceLoad                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::LoadAI(class APhxAISpawner_Character* Spawner, bool bForceLoad)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "LoadAI");

	Params::PhxAIBlueprintLibrary_LoadAI Parms{};

	Parms.Spawner = Spawner;
	Parms.bForceLoad = bForceLoad;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.LoadAIFromComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPhxAISpawnerComponent_Character* SpawnerComponent                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::LoadAIFromComponent(class UPhxAISpawnerComponent_Character* SpawnerComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "LoadAIFromComponent");

	Params::PhxAIBlueprintLibrary_LoadAIFromComponent Parms{};

	Parms.SpawnerComponent = SpawnerComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.LoadAIFromEncounterGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::LoadAIFromEncounterGroup(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "LoadAIFromEncounterGroup");

	Params::PhxAIBlueprintLibrary_LoadAIFromEncounterGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.MakeAIAwareOfPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIAwarenessLevel                    AwarenessLevel                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::MakeAIAwareOfPlayer(class UObject* WorldContext, class AActor* Actor, EPhxAIAwarenessLevel AwarenessLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "MakeAIAwareOfPlayer");

	Params::PhxAIBlueprintLibrary_MakeAIAwareOfPlayer Parms{};

	Parms.WorldContext = WorldContext;
	Parms.Actor = Actor;
	Parms.AwarenessLevel = AwarenessLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.PerformIdle
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::PerformIdle(class APhxAICharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "PerformIdle");

	Params::PhxAIBlueprintLibrary_PerformIdle Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.SetOverrideCompanionChatterSet
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionChatterSetDefinition*ChatterSet                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::SetOverrideCompanionChatterSet(class APhxAICharacter* Character, const class UPhxAICompanionChatterSetDefinition* ChatterSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "SetOverrideCompanionChatterSet");

	Params::PhxAIBlueprintLibrary_SetOverrideCompanionChatterSet Parms{};

	Parms.Character = Character;
	Parms.ChatterSet = ChatterSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.SetOverrideCompanionFidgetSet
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionFidgetSetDefinition*FidgetSet                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::SetOverrideCompanionFidgetSet(class APhxAICharacter* Character, const class UPhxAICompanionFidgetSetDefinition* FidgetSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "SetOverrideCompanionFidgetSet");

	Params::PhxAIBlueprintLibrary_SetOverrideCompanionFidgetSet Parms{};

	Parms.Character = Character;
	Parms.FidgetSet = FidgetSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.SetScriptingMode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIScriptingMode                     ScriptingMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::SetScriptingMode(class APhxAICharacter* Character, EPhxAIScriptingMode ScriptingMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "SetScriptingMode");

	Params::PhxAIBlueprintLibrary_SetScriptingMode Parms{};

	Parms.Character = Character;
	Parms.ScriptingMode = ScriptingMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.StartCompanionScriptedChatter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxAICompanionScriptedChatterDefinition*ScriptedChatter                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::StartCompanionScriptedChatter(class APhxAICharacter* Character, const class UPhxAICompanionScriptedChatterDefinition* ScriptedChatter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "StartCompanionScriptedChatter");

	Params::PhxAIBlueprintLibrary_StartCompanionScriptedChatter Parms{};

	Parms.Character = Character;
	Parms.ScriptedChatter = ScriptedChatter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.StopCompanionScriptedChatter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::StopCompanionScriptedChatter(class APhxAICharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "StopCompanionScriptedChatter");

	Params::PhxAIBlueprintLibrary_StopCompanionScriptedChatter Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.UnloadAI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAISpawner_Character*          Spawner                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::UnloadAI(class APhxAISpawner_Character* Spawner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "UnloadAI");

	Params::PhxAIBlueprintLibrary_UnloadAI Parms{};

	Parms.Spawner = Spawner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.UnloadAIFromComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UPhxAISpawnerComponent_Character* SpawnerComponent                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::UnloadAIFromComponent(class UPhxAISpawnerComponent_Character* SpawnerComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "UnloadAIFromComponent");

	Params::PhxAIBlueprintLibrary_UnloadAIFromComponent Parms{};

	Parms.SpawnerComponent = SpawnerComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIBlueprintLibrary.UnloadAIFromEncounterGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIBlueprintLibrary::UnloadAIFromEncounterGroup(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAIBlueprintLibrary", "UnloadAIFromEncounterGroup");

	Params::PhxAIBlueprintLibrary_UnloadAIFromEncounterGroup Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBloodSpatterComponent.CleanBloodOnCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AmountPerSecond                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxBloodSpatterComponent::CleanBloodOnCharacter(float AmountPerSecond, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBloodSpatterComponent", "CleanBloodOnCharacter");

	Params::PhxBloodSpatterComponent_CleanBloodOnCharacter Parms{};

	Parms.AmountPerSecond = AmountPerSecond;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBloodSpatterComponent.ProcessImpactInBloodZone
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBloodZoneID                            BloodZoneId                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxBloodSpatterComponent::ProcessImpactInBloodZone(EBloodZoneID BloodZoneId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBloodSpatterComponent", "ProcessImpactInBloodZone");

	Params::PhxBloodSpatterComponent_ProcessImpactInBloodZone Parms{};

	Parms.BloodZoneId = BloodZoneId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBloodSpatterComponent.SpawnSpatterDecals
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// EUntaggedWoundType                      DamageType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ImpactNormal                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxBodyPartType                        BodyPart                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   MotionDirection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bChunkDecalsAllowed                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxBloodSpatterComponent::SpawnSpatterDecals(EUntaggedWoundType DamageType, const struct FVector& HitLocation, const struct FVector& ImpactNormal, const struct FVector& Direction, EPhxBodyPartType BodyPart, const struct FVector& MotionDirection, bool bChunkDecalsAllowed, class USceneComponent* HitComponent, class FName SocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBloodSpatterComponent", "SpawnSpatterDecals");

	Params::PhxBloodSpatterComponent_SpawnSpatterDecals Parms{};

	Parms.DamageType = DamageType;
	Parms.HitLocation = std::move(HitLocation);
	Parms.ImpactNormal = std::move(ImpactNormal);
	Parms.Direction = std::move(Direction);
	Parms.BodyPart = BodyPart;
	Parms.MotionDirection = std::move(MotionDirection);
	Parms.bChunkDecalsAllowed = bChunkDecalsAllowed;
	Parms.HitComponent = HitComponent;
	Parms.SocketName = SocketName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterAwarenessComponent_NPC.HandleSelectedTargetDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterAwarenessComponent_NPC::HandleSelectedTargetDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterAwarenessComponent_NPC", "HandleSelectedTargetDestroyed");

	Params::PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterAwarenessComponent_NPC.HandleSelectedTargetDied
// (Final, Native, Private)
// Parameters:
// class UPhxHealthComponent*              HealthComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAICharacterAwarenessComponent_NPC::HandleSelectedTargetDied(class UPhxHealthComponent* HealthComp, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterAwarenessComponent_NPC", "HandleSelectedTargetDied");

	Params::PhxAICharacterAwarenessComponent_NPC_HandleSelectedTargetDied Parms{};

	Parms.HealthComp = HealthComp;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent_Companion.OnPlayerShotFired
// (Final, Native, Private)

void UPhxAICharacterComponent_Companion::OnPlayerShotFired()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Companion", "OnPlayerShotFired");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterComponent_Mahler.IsInFinalState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAICharacterComponent_Mahler::IsInFinalState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Mahler", "IsInFinalState");

	Params::PhxAICharacterComponent_Mahler_IsInFinalState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacterComponent_Mahler.TryTeleport
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FPhxAITeleportRequest&     TeleportRequest                                        (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAICharacterComponent_Mahler::TryTeleport(const struct FPhxAITeleportRequest& TeleportRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterComponent_Mahler", "TryTeleport");

	Params::PhxAICharacterComponent_Mahler_TryTeleport Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacterController.HandleAIDied
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICharacterController::HandleAIDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterController", "HandleAIDied");

	Params::PhxAICharacterController_HandleAIDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterController.HandleOccupiedEncounterNetworkDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICharacterController::HandleOccupiedEncounterNetworkDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterController", "HandleOccupiedEncounterNetworkDestroyed");

	Params::PhxAICharacterController_HandleOccupiedEncounterNetworkDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterController.HandleOccupiedEncounterNetworkEndPlay
// (Final, Native, Private)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEndPlayReason                          EndPlayReason                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICharacterController::HandleOccupiedEncounterNetworkEndPlay(class AActor* Actor, EEndPlayReason EndPlayReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterController", "HandleOccupiedEncounterNetworkEndPlay");

	Params::PhxAICharacterController_HandleOccupiedEncounterNetworkEndPlay Parms{};

	Parms.Actor = Actor;
	Parms.EndPlayReason = EndPlayReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterController.TickBehavior
// (Final, Native, Protected)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICharacterController::TickBehavior(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterController", "TickBehavior");

	Params::PhxAICharacterController_TickBehavior Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICharacterController.GetCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxAICharacter*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAICharacter* APhxAICharacterController::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterController", "GetCharacter");

	Params::PhxAICharacterController_GetCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICharacterController.GetHighestPriorityEnemy
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  OutThreatScore                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* APhxAICharacterController::GetHighestPriorityEnemy(float* OutThreatScore) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICharacterController", "GetHighestPriorityEnemy");

	Params::PhxAICharacterController_GetHighestPriorityEnemy Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSimpleMovingPlatformBase.OnActorRestored
// (Native, Protected)

void APhxSimpleMovingPlatformBase::OnActorRestored()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleMovingPlatformBase", "OnActorRestored");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleMovingPlatformBase.OnPlatformMovementAnimationFinished
// (Final, Native, Protected)

void APhxSimpleMovingPlatformBase::OnPlatformMovementAnimationFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleMovingPlatformBase", "OnPlatformMovementAnimationFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleMovingPlatformBase.OnPlatformMovementAnimationStopped
// (Final, Native, Protected)

void APhxSimpleMovingPlatformBase::OnPlatformMovementAnimationStopped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleMovingPlatformBase", "OnPlatformMovementAnimationStopped");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleMovingPlatformBase.OnPreActorRecorded
// (Native, Protected)

void APhxSimpleMovingPlatformBase::OnPreActorRecorded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleMovingPlatformBase", "OnPreActorRecorded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleMovingPlatformBase.GetPlatformFinishTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform APhxSimpleMovingPlatformBase::GetPlatformFinishTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleMovingPlatformBase", "GetPlatformFinishTransform");

	Params::PhxSimpleMovingPlatformBase_GetPlatformFinishTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSimpleMovingPlatformBase.GetPlatformStartTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform APhxSimpleMovingPlatformBase::GetPlatformStartTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleMovingPlatformBase", "GetPlatformStartTransform");

	Params::PhxSimpleMovingPlatformBase_GetPlatformStartTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxElevatorBase.ClosePrimaryDoor
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::ClosePrimaryDoor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "ClosePrimaryDoor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.CloseSecondaryDoor
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::CloseSecondaryDoor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "CloseSecondaryDoor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.MoveElevatorDown
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::MoveElevatorDown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "MoveElevatorDown");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.MoveElevatorUp
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::MoveElevatorUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "MoveElevatorUp");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.OpenPrimaryDoor
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::OpenPrimaryDoor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "OpenPrimaryDoor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.OpenSecondaryDoor
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::OpenSecondaryDoor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "OpenSecondaryDoor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.StartElevatorAtBottom
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::StartElevatorAtBottom()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "StartElevatorAtBottom");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.StartElevatorAtTop
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::StartElevatorAtTop()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "StartElevatorAtTop");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.StopElevator
// (Native, Public, BlueprintCallable)

void APhxElevatorBase::StopElevator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "StopElevator");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxElevatorBase.IsElevatorOnBottomFloor
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxElevatorBase::IsElevatorOnBottomFloor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "IsElevatorOnBottomFloor");

	Params::PhxElevatorBase_IsElevatorOnBottomFloor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxElevatorBase.IsElevatorOnTopFloor
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxElevatorBase::IsElevatorOnTopFloor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxElevatorBase", "IsElevatorOnTopFloor");

	Params::PhxElevatorBase_IsElevatorOnTopFloor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDoorTransitionComponent.Closed
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDoorTransitionComponent::Closed(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoorTransitionComponent", "Closed");

	Params::PhxDoorTransitionComponent_Closed Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoorTransitionComponent.Opened
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDoorTransitionComponent::Opened(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoorTransitionComponent", "Opened");

	Params::PhxDoorTransitionComponent_Opened Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetCollectionMeterManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAssetCollectionMeterManager*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAssetCollectionMeterManager* UPhxAssetCollectionMeterManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAssetCollectionMeterManager", "Get");

	Params::PhxAssetCollectionMeterManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetCollectionMeterManager.SetAssetCollectionMeterVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Visibility                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetCollectionMeterManager::SetAssetCollectionMeterVisibility(ESlateVisibility Visibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetCollectionMeterManager", "SetAssetCollectionMeterVisibility");

	Params::PhxAssetCollectionMeterManager_SetAssetCollectionMeterVisibility Parms{};

	Parms.Visibility = Visibility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetCollectionMeterManager.GetIsAssetCollectionDetailsVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAssetCollectionMeterManager::GetIsAssetCollectionDetailsVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetCollectionMeterManager", "GetIsAssetCollectionDetailsVisible");

	Params::PhxAssetCollectionMeterManager_GetIsAssetCollectionDetailsVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetCollectionMeterManager.GetIsAssetCollectionMeterVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAssetCollectionMeterManager::GetIsAssetCollectionMeterVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetCollectionMeterManager", "GetIsAssetCollectionMeterVisible");

	Params::PhxAssetCollectionMeterManager_GetIsAssetCollectionMeterVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterSpace.OnBeginOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           MyActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLevelPacingMeterSpace::OnBeginOverlap(class AActor* MyActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterSpace", "OnBeginOverlap");

	Params::PhxLevelPacingMeterSpace_OnBeginOverlap Parms{};

	Parms.MyActor = MyActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterSpace.OnEndOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           MyActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLevelPacingMeterSpace::OnEndOverlap(class AActor* MyActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterSpace", "OnEndOverlap");

	Params::PhxLevelPacingMeterSpace_OnEndOverlap Parms{};

	Parms.MyActor = MyActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterSpace.SetIsActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewActive                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLevelPacingMeterSpace::SetIsActive(bool bNewActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterSpace", "SetIsActive");

	Params::PhxLevelPacingMeterSpace_SetIsActive Parms{};

	Parms.bNewActive = bNewActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterSpace.GetIsActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxLevelPacingMeterSpace::GetIsActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterSpace", "GetIsActive");

	Params::PhxLevelPacingMeterSpace_GetIsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterSpace.GetLevelSpaceType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELevelSpaceType                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ELevelSpaceType APhxLevelPacingMeterSpace::GetLevelSpaceType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterSpace", "GetLevelSpaceType");

	Params::PhxLevelPacingMeterSpace_GetLevelSpaceType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterSpace.GetTimeInSpace
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxLevelPacingMeterSpace::GetTimeInSpace() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterSpace", "GetTimeInSpace");

	Params::PhxLevelPacingMeterSpace_GetTimeInSpace Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterSpace.GetUniqueID
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGuid                      ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FGuid APhxLevelPacingMeterSpace::GetUniqueID() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterSpace", "GetUniqueID");

	Params::PhxLevelPacingMeterSpace_GetUniqueID Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDestroyable.HandleOnOverlap
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxDestroyable::HandleOnOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "HandleOnOverlap");

	Params::PhxDestroyable_HandleOnOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDestroyable.HandleOnOverlapWithNearDestroyable
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxDestroyable::HandleOnOverlapWithNearDestroyable(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "HandleOnOverlapWithNearDestroyable");

	Params::PhxDestroyable_HandleOnOverlapWithNearDestroyable Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDestroyable.HandleTakeAnyDamage
// (Final, Native, Public)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDestroyable::HandleTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "HandleTakeAnyDamage");

	Params::PhxDestroyable_HandleTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDestroyable.OnBreakBP
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           InBreakingActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ByOtherDestroyable                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDestroyable::OnBreakBP(class AActor* InBreakingActor, bool ByOtherDestroyable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "OnBreakBP");

	Params::PhxDestroyable_OnBreakBP Parms{};

	Parms.InBreakingActor = InBreakingActor;
	Parms.ByOtherDestroyable = ByOtherDestroyable;

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


// Function Phoenix.PhxDestroyable.OnPartHitBP
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDestroyable::OnPartHitBP(const struct FHitResult& Hit, const struct FVector& NormalImpulse, class UPrimitiveComponent* HitComp, class UPrimitiveComponent* OtherComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "OnPartHitBP");

	Params::PhxDestroyable_OnPartHitBP Parms{};

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

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


// Function Phoenix.PhxDestroyable.OnPartHitCallback
// (Final, Native, Public, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "OnPartHitCallback");

	Params::PhxDestroyable_OnPartHitCallback Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDestroyable.OnPartPutToSleep
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              InComp                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             InBoneName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDestroyable::OnPartPutToSleep(class UPrimitiveComponent* InComp, class FName InBoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "OnPartPutToSleep");

	Params::PhxDestroyable_OnPartPutToSleep Parms{};

	Parms.InComp = InComp;
	Parms.InBoneName = InBoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDestroyable.IsDestroyed
// (Final, Native, Public, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxDestroyable::IsDestroyed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDestroyable", "IsDestroyed");

	Params::PhxDestroyable_IsDestroyed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.AreScreenMessagesEnabled
// (Final, Native, Static, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::AreScreenMessagesEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "AreScreenMessagesEnabled");

	Params::PhxDebugBlueprintLibrary_AreScreenMessagesEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.DebugStartLoadingScreen
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class ULevelTransitionDataAsset*  LevelTransitionData                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDebugBlueprintLibrary::DebugStartLoadingScreen(class UObject* WorldContextObject, const class ULevelTransitionDataAsset* LevelTransitionData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "DebugStartLoadingScreen");

	Params::PhxDebugBlueprintLibrary_DebugStartLoadingScreen Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelTransitionData = LevelTransitionData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDebugBlueprintLibrary.DebugStopLoadingScreen
// (Final, Native, Static, Private, BlueprintCallable)

void UPhxDebugBlueprintLibrary::DebugStopLoadingScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "DebugStopLoadingScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDebugBlueprintLibrary.GetSimulateInEditorViewTransformWrapper
// (Final, Native, Static, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FTransform*                      OutViewTransform                                       (Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::GetSimulateInEditorViewTransformWrapper(struct FTransform* OutViewTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "GetSimulateInEditorViewTransformWrapper");

	Params::PhxDebugBlueprintLibrary_GetSimulateInEditorViewTransformWrapper Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.IsEngineShowFlagEnabled
// (Final, Native, Static, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    FlagString                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::IsEngineShowFlagEnabled(class UObject* WorldContextObject, const class FString& FlagString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "IsEngineShowFlagEnabled");

	Params::PhxDebugBlueprintLibrary_IsEngineShowFlagEnabled Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.FlagString = std::move(FlagString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.IsGameplayDebuggerCategoryEnabled
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CategoryId                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::IsGameplayDebuggerCategoryEnabled(class UObject* WorldContextObject, int32 CategoryId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "IsGameplayDebuggerCategoryEnabled");

	Params::PhxDebugBlueprintLibrary_IsGameplayDebuggerCategoryEnabled Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.CategoryId = CategoryId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.IsGameplayDebuggerEnabled
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::IsGameplayDebuggerEnabled(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "IsGameplayDebuggerEnabled");

	Params::PhxDebugBlueprintLibrary_IsGameplayDebuggerEnabled Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.IsLevelStreamingFrozen
// (Final, Native, Static, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::IsLevelStreamingFrozen(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "IsLevelStreamingFrozen");

	Params::PhxDebugBlueprintLibrary_IsLevelStreamingFrozen Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.IsRayTracingEnabled
// (Final, Native, Static, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::IsRayTracingEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "IsRayTracingEnabled");

	Params::PhxDebugBlueprintLibrary_IsRayTracingEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.IsRenderingFrozen
// (Final, Native, Static, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::IsRenderingFrozen(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "IsRenderingFrozen");

	Params::PhxDebugBlueprintLibrary_IsRenderingFrozen Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.IsStatEnabled
// (Final, Native, Static, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    StatString                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDebugBlueprintLibrary::IsStatEnabled(class UObject* WorldContextObject, const class FString& StatString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "IsStatEnabled");

	Params::PhxDebugBlueprintLibrary_IsStatEnabled Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.StatString = std::move(StatString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugBlueprintLibrary.OutputStringToFile
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// const class FString&                    StringData                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAppend                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    FileNameWithExt                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDebugBlueprintLibrary::OutputStringToFile(const class FString& StringData, bool bAppend, const class FString& FileNameWithExt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "OutputStringToFile");

	Params::PhxDebugBlueprintLibrary_OutputStringToFile Parms{};

	Parms.StringData = std::move(StringData);
	Parms.bAppend = bAppend;
	Parms.FileNameWithExt = std::move(FileNameWithExt);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDebugBlueprintLibrary.PhxPauseEditor
// (Final, Native, Static, Private, BlueprintCallable)

void UPhxDebugBlueprintLibrary::PhxPauseEditor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugBlueprintLibrary", "PhxPauseEditor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIResource_Charge.OnCharacterRecievedDamage
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIResource_Charge::OnCharacterRecievedDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIResource_Charge", "OnCharacterRecievedDamage");

	Params::PhxAIResource_Charge_OnCharacterRecievedDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInteractableInterface.CanInteract
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IPhxInteractableInterface::CanInteract() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxInteractableInterface", "CanInteract");

	Params::PhxInteractableInterface_CanInteract Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputRecorder.OnInputAxis
// (Final, Native, Private)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Delta                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             DeltaTime                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             NumSamples                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxInputRecorder::OnInputAxis(const struct FKey& Key, const float Delta, const float DeltaTime, const int32 NumSamples)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputRecorder", "OnInputAxis");

	Params::PhxInputRecorder_OnInputAxis Parms{};

	Parms.Key = std::move(Key);
	Parms.Delta = Delta;
	Parms.DeltaTime = DeltaTime;
	Parms.NumSamples = NumSamples;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInputRecorder.OnInputKey
// (Final, Native, Private)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputEvent                       EventType                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             AmountDepressed                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxInputRecorder::OnInputKey(const struct FKey& Key, const EInputEvent EventType, const float AmountDepressed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputRecorder", "OnInputKey");

	Params::PhxInputRecorder_OnInputKey Parms{};

	Parms.Key = std::move(Key);
	Parms.EventType = EventType;
	Parms.AmountDepressed = AmountDepressed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHasAnyOfEntitlements.HasAnyOfEntitlement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const TArray<EPhxEntitlement>&          InEntitlements                                         (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UPhxHasAnyOfEntitlements*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxHasAnyOfEntitlements* UPhxHasAnyOfEntitlements::HasAnyOfEntitlement(const TArray<EPhxEntitlement>& InEntitlements)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxHasAnyOfEntitlements", "HasAnyOfEntitlement");

	Params::PhxHasAnyOfEntitlements_HasAnyOfEntitlement Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHasAnyOfEntitlements.HandleFetchEntitlements
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxEntitlementOwnership&  Ownership                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxHasAnyOfEntitlements::HandleFetchEntitlements(const struct FPhxEntitlementOwnership& Ownership)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasAnyOfEntitlements", "HandleFetchEntitlements");

	Params::PhxHasAnyOfEntitlements_HandleFetchEntitlements Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHasAnyOfEntitlements.HandleFetchOnlineAccount
// (Final, Native, Protected)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USDSOnlineAccount*          OnlineAccount                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHasAnyOfEntitlements::HandleFetchOnlineAccount(bool bSuccess, const class USDSOnlineAccount* OnlineAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasAnyOfEntitlements", "HandleFetchOnlineAccount");

	Params::PhxHasAnyOfEntitlements_HandleFetchOnlineAccount Parms{};

	Parms.bSuccess = bSuccess;
	Parms.OnlineAccount = OnlineAccount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PlayDead.OnActorRecievedDamage
// (Final, Native, Private)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_PlayDead::OnActorRecievedDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PlayDead", "OnActorRecievedDamage");

	Params::PhxAIGameplayAbility_PlayDead_OnActorRecievedDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PlayDead.OnGetUpMontageEnded
// (Final, Native, Private)

void UPhxAIGameplayAbility_PlayDead::OnGetUpMontageEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PlayDead", "OnGetUpMontageEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_PlayDead.OnPlayerApproach
// (Final, Native, Private)

void UPhxAIGameplayAbility_PlayDead::OnPlayerApproach()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_PlayDead", "OnPlayerApproach");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SplineState.GetDistanceAlongSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    normalized                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float USplineState::GetDistanceAlongSpline(bool normalized) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineState", "GetDistanceAlongSpline");

	Params::SplineState_GetDistanceAlongSpline Parms{};

	Parms.normalized = normalized;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SplineState.GetFinishingEnd
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ESplineEnd                              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESplineEnd USplineState::GetFinishingEnd() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineState", "GetFinishingEnd");

	Params::SplineState_GetFinishingEnd Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SplineMontageState.GetClampedMontagePosition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float USplineMontageState::GetClampedMontagePosition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineMontageState", "GetClampedMontagePosition");

	Params::SplineMontageState_GetClampedMontagePosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SplineMontageState.GetCycledMontagePosition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float USplineMontageState::GetCycledMontagePosition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineMontageState", "GetCycledMontagePosition");

	Params::SplineMontageState_GetCycledMontagePosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAICompanionPOIVolume.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInEnabled                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAICompanionPOIVolume::SetEnabled(bool bInEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAICompanionPOIVolume", "SetEnabled");

	Params::PhxAICompanionPOIVolume_SetEnabled Parms{};

	Parms.bInEnabled = bInEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAICompanionScriptingHandoffInterface.HandoffCompanionScripting
// (Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxAICompanionScriptingHandoffInterface::HandoffCompanionScripting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxAICompanionScriptingHandoffInterface", "HandoffCompanionScripting");

	AsUObject()->ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAIDefensiveActionsComponent.SetBlockProbability
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   InProbability                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIDefensiveActionsComponent::SetBlockProbability(float InProbability)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIDefensiveActionsComponent", "SetBlockProbability");

	Params::PhxAIDefensiveActionsComponent_SetBlockProbability Parms{};

	Parms.InProbability = InProbability;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIDefensiveActionsComponent.SetDodgeProbability
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   InProbability                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIDefensiveActionsComponent::SetDodgeProbability(float InProbability)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIDefensiveActionsComponent", "SetDodgeProbability");

	Params::PhxAIDefensiveActionsComponent_SetDodgeProbability Parms{};

	Parms.InProbability = InProbability;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveDescriptor.GetTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAIEncounterGroupWaveDescriptor::GetTag() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveDescriptor", "GetTag");

	Params::PhxAIEncounterGroupWaveDescriptor_GetTag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_BlueprintBase.ReceiveStartPlay
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIEncounterGroupWaveBeginCondition_BlueprintBase::ReceiveStartPlay(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_BlueprintBase", "ReceiveStartPlay");

	Params::PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveStartPlay Parms{};

	Parms.EncounterGroup = EncounterGroup;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_BlueprintBase.ReceiveEvaluateCondition
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIEncounterGroupWaveBeginCondition_BlueprintBase::ReceiveEvaluateCondition(class APhxAIEncounterGroup* EncounterGroup, class FName Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_BlueprintBase", "ReceiveEvaluateCondition");

	Params::PhxAIEncounterGroupWaveBeginCondition_BlueprintBase_ReceiveEvaluateCondition Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.Tag = Tag;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemySlam.OnEndMontageCancelledOrInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemySlam::OnEndMontageCancelledOrInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemySlam", "OnEndMontageCancelledOrInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemySlam.OnEndMontageFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemySlam::OnEndMontageFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemySlam", "OnEndMontageFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemySlam.OnEnemyHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemySlam", "OnEnemyHit");

	Params::PhxGameplayAbility_PPEEnemySlam_OnEnemyHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemySlam.OnPPEMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemySlam::OnPPEMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemySlam", "OnPPEMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger.OnActorBeginOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_PlayerTrigger::OnActorBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger", "OnActorBeginOverlap");

	Params::PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger.OnActorEndOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_PlayerTrigger::OnActorEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger", "OnActorEndOverlap");

	Params::PhxAIEncounterGroupWaveBeginCondition_PlayerTrigger_OnActorEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_WaveSpawned.OnWaveSpawned
// (Final, Native, Private)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIEncounterGroupWaveDescriptor*WaveDescriptor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_WaveSpawned::OnWaveSpawned(class APhxAIEncounterGroup* EncounterGroup, class UPhxAIEncounterGroupWaveDescriptor* WaveDescriptor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_WaveSpawned", "OnWaveSpawned");

	Params::PhxAIEncounterGroupWaveBeginCondition_WaveSpawned_OnWaveSpawned Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.WaveDescriptor = WaveDescriptor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerInterface.SpawnAI
// (Native, Event, Public, BlueprintEvent)

void IPhxAISpawnerInterface::SpawnAI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxAISpawnerInterface", "SpawnAI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerInterface.GetSpawnerComponent
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class UPhxAISpawnerComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAISpawnerComponent* IPhxAISpawnerInterface::GetSpawnerComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxAISpawnerInterface", "GetSpawnerComponent");

	Params::PhxAISpawnerInterface_GetSpawnerComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_WaveCompleted.OnWaveCompleted
// (Final, Native, Private)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIEncounterGroupWaveDescriptor*WaveDescriptor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_WaveCompleted::OnWaveCompleted(class APhxAIEncounterGroup* EncounterGroup, class UPhxAIEncounterGroupWaveDescriptor* WaveDescriptor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_WaveCompleted", "OnWaveCompleted");

	Params::PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveCompleted Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.WaveDescriptor = WaveDescriptor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_WaveCompleted.OnWaveFakeCompleted
// (Final, Native, Private)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIEncounterGroupWaveDescriptor*WaveDescriptor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_WaveCompleted::OnWaveFakeCompleted(class APhxAIEncounterGroup* EncounterGroup, class UPhxAIEncounterGroupWaveDescriptor* WaveDescriptor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_WaveCompleted", "OnWaveFakeCompleted");

	Params::PhxAIEncounterGroupWaveBeginCondition_WaveCompleted_OnWaveFakeCompleted Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.WaveDescriptor = WaveDescriptor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTrackableGoreActor.OnGoreSleep
// (Event, Protected, BlueprintEvent)

void APhxTrackableGoreActor::OnGoreSleep()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTrackableGoreActor", "OnGoreSleep");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited.OnSafeRoomExited
// (Final, Native, Private)
// Parameters:
// int32                                   InSafeRoomIndex                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_SafeRoomExited::OnSafeRoomExited(int32 InSafeRoomIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited", "OnSafeRoomExited");

	Params::PhxAIEncounterGroupWaveBeginCondition_SafeRoomExited_OnSafeRoomExited Parms{};

	Parms.InSafeRoomIndex = InSafeRoomIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned.OnWaveSpawned
// (Native, Protected)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAIEncounterGroupWaveDescriptor*WaveDescriptor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned::OnWaveSpawned(class APhxAIEncounterGroup* EncounterGroup, class UPhxAIEncounterGroupWaveDescriptor* WaveDescriptor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned", "OnWaveSpawned");

	Params::PhxAIEncounterGroupWaveBeginCondition_ConditionSinceWaveSpawned_OnWaveSpawned Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.WaveDescriptor = WaveDescriptor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned.OnNPCKilledOrDestroyed
// (Final, Native, Protected)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned::OnNPCKilledOrDestroyed(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned", "OnNPCKilledOrDestroyed");

	Params::PhxAIEncounterGroupWaveBeginCondition_KillsSinceWaveSpawned_OnNPCKilledOrDestroyed Parms{};

	Parms.EncounterGroup = EncounterGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase.ReceiveStartPlay
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIEncounterGroupWaveCompletedCondition_BlueprintBase::ReceiveStartPlay(class APhxAIEncounterGroup* EncounterGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase", "ReceiveStartPlay");

	Params::PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveStartPlay Parms{};

	Parms.EncounterGroup = EncounterGroup;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase.ReceiveEvaluateCondition
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// class APhxAIEncounterGroup*             EncounterGroup                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAIEncounterGroupWaveCompletedCondition_BlueprintBase::ReceiveEvaluateCondition(class APhxAIEncounterGroup* EncounterGroup, class FName Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase", "ReceiveEvaluateCondition");

	Params::PhxAIEncounterGroupWaveCompletedCondition_BlueprintBase_ReceiveEvaluateCondition Parms{};

	Parms.EncounterGroup = EncounterGroup;
	Parms.Tag = Tag;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility_UseConsumable.OnMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_UseConsumable::OnMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UseConsumable", "OnMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UseConsumable.OnMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_UseConsumable::OnMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UseConsumable", "OnMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UseConsumable.OnNotifyReceived
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_UseConsumable::OnNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UseConsumable", "OnNotifyReceived");

	Params::PhxGameplayAbility_UseConsumable_OnNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UseConsumable.OnUseConsumableCanceled
// (Final, Native, Protected)

void UPhxGameplayAbility_UseConsumable::OnUseConsumableCanceled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UseConsumable", "OnUseConsumableCanceled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterNetwork.HandleAIDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterNetwork::HandleAIDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterNetwork", "HandleAIDestroyed");

	Params::PhxAIEncounterNetwork_HandleAIDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterNetwork.HandleAIDied
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterNetwork::HandleAIDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterNetwork", "HandleAIDied");

	Params::PhxAIEncounterNetwork_HandleAIDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterNetwork.HandleAIInsideStateChanged
// (Final, Native, Private)
// Parameters:
// class APhxAICharacter*                  AICharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIEncounterNetworkUserInsideState   OldState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIEncounterNetworkUserInsideState   NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterNetwork::HandleAIInsideStateChanged(class APhxAICharacter* AICharacter, EPhxAIEncounterNetworkUserInsideState OldState, EPhxAIEncounterNetworkUserInsideState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterNetwork", "HandleAIInsideStateChanged");

	Params::PhxAIEncounterNetwork_HandleAIInsideStateChanged Parms{};

	Parms.AICharacter = AICharacter;
	Parms.OldState = OldState;
	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Transform.OnTransformMontageCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Transform::OnTransformMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Transform", "OnTransformMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoOnceNode.PhxDoOnce
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    Key                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDoOncePath*                            Path                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDoOnceNode::PhxDoOnce(const class FString& Key, EDoOncePath* Path)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDoOnceNode", "PhxDoOnce");

	Params::PhxDoOnceNode_PhxDoOnce Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxAISpawnerComponent_Character.SetAttributeVariation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxAICharacterVariantDefinition* InAttributeVariation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawnerComponent_Character::SetAttributeVariation(class UPhxAICharacterVariantDefinition* InAttributeVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "SetAttributeVariation");

	Params::PhxAISpawnerComponent_Character_SetAttributeVariation Parms{};

	Parms.InAttributeVariation = InAttributeVariation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent_Character.SetBlueprintVariation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InBlueprintVariation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawnerComponent_Character::SetBlueprintVariation(int32 InBlueprintVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "SetBlueprintVariation");

	Params::PhxAISpawnerComponent_Character_SetBlueprintVariation Parms{};

	Parms.InBlueprintVariation = InBlueprintVariation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent_Character.SetCharacterDefinition
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSoftObjectPtr<class UPhxAICharacterDefinition>&InAICharacterDefinitionPtr                             (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InCharacterVariation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawnerComponent_Character::SetCharacterDefinition(const TSoftObjectPtr<class UPhxAICharacterDefinition>& InAICharacterDefinitionPtr, int32 InCharacterVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "SetCharacterDefinition");

	Params::PhxAISpawnerComponent_Character_SetCharacterDefinition Parms{};

	Parms.InAICharacterDefinitionPtr = InAICharacterDefinitionPtr;
	Parms.InCharacterVariation = InCharacterVariation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent_Character.SetSpawnAwareOfPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxAIAwarenessLevel                    InAwarenessLevel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISpawnerComponent_Character::SetSpawnAwareOfPlayer(EPhxAIAwarenessLevel InAwarenessLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "SetSpawnAwareOfPlayer");

	Params::PhxAISpawnerComponent_Character_SetSpawnAwareOfPlayer Parms{};

	Parms.InAwarenessLevel = InAwarenessLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent_Character.SetSpawnTags
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     InSpawnTags                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxAISpawnerComponent_Character::SetSpawnTags(const struct FGameplayTagContainer& InSpawnTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "SetSpawnTags");

	Params::PhxAISpawnerComponent_Character_SetSpawnTags Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetAllowPlayerFinisher
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetAllowPlayerFinisher() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetAllowPlayerFinisher");

	Params::PhxAISpawnerComponent_Character_GetAllowPlayerFinisher Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetAttributeVariation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSoftObjectPtr<class UPhxAICharacterVariantDefinition>ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class UPhxAICharacterVariantDefinition> UPhxAISpawnerComponent_Character::GetAttributeVariation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetAttributeVariation");

	Params::PhxAISpawnerComponent_Character_GetAttributeVariation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetAutoLoad
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAISpawnerComponent_Character::GetAutoLoad() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetAutoLoad");

	Params::PhxAISpawnerComponent_Character_GetAutoLoad Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetAutoRespawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAISpawnerComponent_Character::GetAutoRespawn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetAutoRespawn");

	Params::PhxAISpawnerComponent_Character_GetAutoRespawn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetBlueprintVariation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxAISpawnerComponent_Character::GetBlueprintVariation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetBlueprintVariation");

	Params::PhxAISpawnerComponent_Character_GetBlueprintVariation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetCanSpawnOffNavMesh
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAISpawnerComponent_Character::GetCanSpawnOffNavMesh() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetCanSpawnOffNavMesh");

	Params::PhxAISpawnerComponent_Character_GetCanSpawnOffNavMesh Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetCharacterDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSoftObjectPtr<class UPhxAICharacterDefinition>ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class UPhxAICharacterDefinition> UPhxAISpawnerComponent_Character::GetCharacterDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetCharacterDefinition");

	Params::PhxAISpawnerComponent_Character_GetCharacterDefinition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetCharacterTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetCharacterTag() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetCharacterTag");

	Params::PhxAISpawnerComponent_Character_GetCharacterTag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetDefendZone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetDefendZone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetDefendZone");

	Params::PhxAISpawnerComponent_Character_GetDefendZone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetDynamicDropsDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetDynamicDropsDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetDynamicDropsDefinition");

	Params::PhxAISpawnerComponent_Character_GetDynamicDropsDefinition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetEnableVariationAutoPopulation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAISpawnerComponent_Character::GetEnableVariationAutoPopulation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetEnableVariationAutoPopulation");

	Params::PhxAISpawnerComponent_Character_GetEnableVariationAutoPopulation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetEncounterGroup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APhxAIEncounterGroup*       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class APhxAIEncounterGroup* UPhxAISpawnerComponent_Character::GetEncounterGroup() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetEncounterGroup");

	Params::PhxAISpawnerComponent_Character_GetEncounterGroup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetMaxSpawns
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetMaxSpawns() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetMaxSpawns");

	Params::PhxAISpawnerComponent_Character_GetMaxSpawns Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetPatrol
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetPatrol() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetPatrol");

	Params::PhxAISpawnerComponent_Character_GetPatrol Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetPointOfInterset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetPointOfInterset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetPointOfInterset");

	Params::PhxAISpawnerComponent_Character_GetPointOfInterset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetPreload
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetPreload() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetPreload");

	Params::PhxAISpawnerComponent_Character_GetPreload Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetScriptngMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetScriptngMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetScriptngMode");

	Params::PhxAISpawnerComponent_Character_GetScriptngMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnAnimation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetSpawnAnimation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetSpawnAnimation");

	Params::PhxAISpawnerComponent_Character_GetSpawnAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnAwareOfPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxAIAwarenessLevel                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxAIAwarenessLevel UPhxAISpawnerComponent_Character::GetSpawnAwareOfPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetSpawnAwareOfPlayer");

	Params::PhxAISpawnerComponent_Character_GetSpawnAwareOfPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnDialogue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetSpawnDialogue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetSpawnDialogue");

	Params::PhxAISpawnerComponent_Character_GetSpawnDialogue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnDialogueDelay
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetSpawnDialogueDelay() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetSpawnDialogueDelay");

	Params::PhxAISpawnerComponent_Character_GetSpawnDialogueDelay Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetSpawnTags
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAISpawnerComponent_Character::GetSpawnTags() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetSpawnTags");

	Params::PhxAISpawnerComponent_Character_GetSpawnTags Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAISpawnerComponent_Character.GetVocalVariation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSoftObjectPtr<class UAkSwitchValue>    ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class UAkSwitchValue> UPhxAISpawnerComponent_Character::GetVocalVariation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISpawnerComponent_Character", "GetVocalVariation");

	Params::PhxAISpawnerComponent_Character_GetVocalVariation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAINavigationLink.UpdateEditorPreview
// (Final, Native, Protected)

void APhxAINavigationLink::UpdateEditorPreview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAINavigationLink", "UpdateEditorPreview");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyHold.OnFinalMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_GRPEnemyHold::OnFinalMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyHold", "OnFinalMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyHold.OnMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_GRPEnemyHold::OnMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyHold", "OnMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterSettingsVolume.DisableHidingPoints
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   NavigationSurfaces                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterSettingsVolume::DisableHidingPoints(int32 NavigationSurfaces)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterSettingsVolume", "DisableHidingPoints");

	Params::PhxAIEncounterSettingsVolume_DisableHidingPoints Parms{};

	Parms.NavigationSurfaces = NavigationSurfaces;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIEncounterSettingsVolume.EnableHidingPoints
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   NavigationSurfaces                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIEncounterSettingsVolume::EnableHidingPoints(int32 NavigationSurfaces)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIEncounterSettingsVolume", "EnableHidingPoints");

	Params::PhxAIEncounterSettingsVolume_EnableHidingPoints Parms{};

	Parms.NavigationSurfaces = NavigationSurfaces;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Montage.OnEventRecieved
// (Final, Native, Protected)
// Parameters:
// const struct FGameplayEventData&        EventData                                              (Parm, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Montage::OnEventRecieved(const struct FGameplayEventData& EventData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Montage", "OnEventRecieved");

	Params::PhxGameplayAbility_Montage_OnEventRecieved Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Montage.OnMontageBlendOut
// (Final, Native, Protected)

void UPhxGameplayAbility_Montage::OnMontageBlendOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Montage", "OnMontageBlendOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Montage.OnMontageCancelled
// (Final, Native, Protected)

void UPhxGameplayAbility_Montage::OnMontageCancelled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Montage", "OnMontageCancelled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Montage.OnMontageComplete
// (Final, Native, Protected)

void UPhxGameplayAbility_Montage::OnMontageComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Montage", "OnMontageComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Montage.OnMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_Montage::OnMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Montage", "OnMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Montage.OnMontageLoopingComplete
// (Final, Native, Protected)

void UPhxGameplayAbility_Montage::OnMontageLoopingComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Montage", "OnMontageLoopingComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGRPHitResponseComponent.OnGRPHitBPE
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FPPEHitResponseData&       ResponseData                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxGRPHitResponseComponent::OnGRPHitBPE(const struct FPPEHitResponseData& ResponseData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPHitResponseComponent", "OnGRPHitBPE");

	Params::PhxGRPHitResponseComponent_OnGRPHitBPE Parms{};

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

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


// Function Phoenix.PhxGRPHitResponseComponent.OnGRPPushBPE
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Instigator                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ShotPower                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGRPHitResponseComponent::OnGRPPushBPE(const struct FVector& Direction, class AActor* Instigator, class AActor* Weapon, float ShotPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPHitResponseComponent", "OnGRPPushBPE");

	Params::PhxGRPHitResponseComponent_OnGRPPushBPE Parms{};

	Parms.Direction = std::move(Direction);
	Parms.Instigator = Instigator;
	Parms.Weapon = Weapon;
	Parms.ShotPower = ShotPower;

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


// Function Phoenix.PhxGRPHitResponseComponent.OnGRPReleaseBPE
// (Event, Public, BlueprintEvent)

void UPhxGRPHitResponseComponent::OnGRPReleaseBPE()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPHitResponseComponent", "OnGRPReleaseBPE");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxAIPointOfInterestActivatorComponent.DisableProximityBubble
// (Final, Native, Public, BlueprintCallable)

void UPhxAIPointOfInterestActivatorComponent::DisableProximityBubble()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterestActivatorComponent", "DisableProximityBubble");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIPointOfInterestActivatorComponent.DisableProximityBubbleLineOfSightCheck
// (Final, Native, Public, BlueprintCallable)

void UPhxAIPointOfInterestActivatorComponent::DisableProximityBubbleLineOfSightCheck()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterestActivatorComponent", "DisableProximityBubbleLineOfSightCheck");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIPointOfInterestActivatorComponent.EnableProximityBubble
// (Final, Native, Public, BlueprintCallable)

void UPhxAIPointOfInterestActivatorComponent::EnableProximityBubble()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterestActivatorComponent", "EnableProximityBubble");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIPointOfInterestActivatorComponent.EnableProximityBubbleLineOfSightCheck
// (Final, Native, Public, BlueprintCallable)

void UPhxAIPointOfInterestActivatorComponent::EnableProximityBubbleLineOfSightCheck()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterestActivatorComponent", "EnableProximityBubbleLineOfSightCheck");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIPointOfInterestActivatorComponent.SetProximityBubbleScale
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HalfHeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIPointOfInterestActivatorComponent::SetProximityBubbleScale(float Radius, float HalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIPointOfInterestActivatorComponent", "SetProximityBubbleScale");

	Params::PhxAIPointOfInterestActivatorComponent_SetProximityBubbleScale Parms{};

	Parms.Radius = Radius;
	Parms.HalfHeight = HalfHeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIFightSystem.OnAnyAttackPerformed
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    Attacker                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     AttackState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIFightSystem::OnAnyAttackPerformed(class APhxCharacter* Attacker, class UAttackState* AttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIFightSystem", "OnAnyAttackPerformed");

	Params::PhxAIFightSystem_OnAnyAttackPerformed Parms{};

	Parms.Attacker = Attacker;
	Parms.AttackState = AttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_AirAttack.HandleAttackEnded
// (Final, Native, Private)

void UPhxAIGameplayAbility_AirAttack::HandleAttackEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_AirAttack", "HandleAttackEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_AirAttack.OnLaunchCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_AirAttack::OnLaunchCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_AirAttack", "OnLaunchCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_AirAttack.OnTargetReached
// (Final, Native, Private)

void UPhxAIGameplayAbility_AirAttack::OnTargetReached()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_AirAttack", "OnTargetReached");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Ambush.OnEventRecieved
// (Final, Native, Private)
// Parameters:
// const struct FGameplayEventData&        EventData                                              (Parm, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_Ambush::OnEventRecieved(const struct FGameplayEventData& EventData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Ambush", "OnEventRecieved");

	Params::PhxAIGameplayAbility_Ambush_OnEventRecieved Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Ambush.OnExitCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Ambush::OnExitCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Ambush", "OnExitCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Ambush.OnExitLoopRequested
// (Final, Native, Private)

void UPhxAIGameplayAbility_Ambush::OnExitLoopRequested()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Ambush", "OnExitLoopRequested");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Ambush.OnReceivedDamage
// (Final, Native, Private)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_Ambush::OnReceivedDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Ambush", "OnReceivedDamage");

	Params::PhxAIGameplayAbility_Ambush_OnReceivedDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_MontageAttack.OnMontageCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_MontageAttack::OnMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_MontageAttack", "OnMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_AoEAttack.OnAoEAttackNotifyReceived
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_AoEAttack::OnAoEAttackNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_AoEAttack", "OnAoEAttackNotifyReceived");

	Params::PhxAIGameplayAbility_AoEAttack_OnAoEAttackNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Attack.HandleAttackEnded
// (Final, Native, Private)

void UPhxAIGameplayAbility_Attack::HandleAttackEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Attack", "HandleAttackEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBloodSpatterTraceManager.ParticleTraceAtLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraSystem*                   SystemTemplate                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnRotation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   MotionVector                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBloodSpatterMaterials&    Materials                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bAllowChunkDecals                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraComponent*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNiagaraComponent* UPhxBloodSpatterTraceManager::ParticleTraceAtLocation(const class UObject* WorldContextObject, class UNiagaraSystem* SystemTemplate, const struct FVector& SpawnLocation, const struct FRotator& SpawnRotation, const struct FVector& MotionVector, const struct FBloodSpatterMaterials& Materials, bool bAllowChunkDecals)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBloodSpatterTraceManager", "ParticleTraceAtLocation");

	Params::PhxBloodSpatterTraceManager_ParticleTraceAtLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SystemTemplate = SystemTemplate;
	Parms.SpawnLocation = std::move(SpawnLocation);
	Parms.SpawnRotation = std::move(SpawnRotation);
	Parms.MotionVector = std::move(MotionVector);
	Parms.Materials = std::move(Materials);
	Parms.bAllowChunkDecals = bAllowChunkDecals;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxBloodSpatterTraceManager.ParticleTraceAttached
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UNiagaraSystem*                   SystemTemplate                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  AttachTo                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RelativeSpawnLocation                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  RelativeSpawnRotation                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   MotionVector                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBloodSpatterMaterials&    Materials                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bAllowChunkDecals                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachLocation                         LocationType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAutoDestroy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraComponent*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNiagaraComponent* UPhxBloodSpatterTraceManager::ParticleTraceAttached(class UNiagaraSystem* SystemTemplate, class USceneComponent* AttachTo, class FName SocketName, const struct FVector& RelativeSpawnLocation, const struct FRotator& RelativeSpawnRotation, const struct FVector& MotionVector, const struct FBloodSpatterMaterials& Materials, bool bAllowChunkDecals, EAttachLocation LocationType, bool bAutoDestroy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBloodSpatterTraceManager", "ParticleTraceAttached");

	Params::PhxBloodSpatterTraceManager_ParticleTraceAttached Parms{};

	Parms.SystemTemplate = SystemTemplate;
	Parms.AttachTo = AttachTo;
	Parms.SocketName = SocketName;
	Parms.RelativeSpawnLocation = std::move(RelativeSpawnLocation);
	Parms.RelativeSpawnRotation = std::move(RelativeSpawnRotation);
	Parms.MotionVector = std::move(MotionVector);
	Parms.Materials = std::move(Materials);
	Parms.bAllowChunkDecals = bAllowChunkDecals;
	Parms.LocationType = LocationType;
	Parms.bAutoDestroy = bAutoDestroy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnAttachMontageFinised
// (Final, Native, Private)

void UPhxAIGameplayAbility_BloodwormAttack::OnAttachMontageFinised()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_BloodwormAttack", "OnAttachMontageFinised");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnAttachNotifyReceived
// (Final, Native, Private)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_BloodwormAttack::OnAttachNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_BloodwormAttack", "OnAttachNotifyReceived");

	Params::PhxAIGameplayAbility_BloodwormAttack_OnAttachNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnAttackFailed
// (Final, Native, Private)

void UPhxAIGameplayAbility_BloodwormAttack::OnAttackFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_BloodwormAttack", "OnAttackFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnEquipNotifyReceived
// (Final, Native, Private)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_BloodwormAttack::OnEquipNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_BloodwormAttack", "OnEquipNotifyReceived");

	Params::PhxAIGameplayAbility_BloodwormAttack_OnEquipNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_BloodwormAttack.OnFinalBlowNotifyReceived
// (Final, Native, Private)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_BloodwormAttack::OnFinalBlowNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_BloodwormAttack", "OnFinalBlowNotifyReceived");

	Params::PhxAIGameplayAbility_BloodwormAttack_OnFinalBlowNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnAlignmentComplete
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnAlignmentComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnAlignmentComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnEscapeCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnEscapeCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnEscapeCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnFailCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnFailCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnFailCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnGrappleCompleted
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnGrappleCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnGrappleCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnGrappleStateEntered
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     InAttackState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_Grapple::OnGrappleStateEntered(class APhxCharacter* InCharacter, class UAttackState* InAttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnGrappleStateEntered");

	Params::PhxAIGameplayAbility_Grapple_OnGrappleStateEntered Parms{};

	Parms.InCharacter = InCharacter;
	Parms.InAttackState = InAttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnGrappleStateExited
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     InAttackState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_Grapple::OnGrappleStateExited(class APhxCharacter* InCharacter, class UAttackState* InAttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnGrappleStateExited");

	Params::PhxAIGameplayAbility_Grapple_OnGrappleStateExited Parms{};

	Parms.InCharacter = InCharacter;
	Parms.InAttackState = InAttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnQTECompleted
// (Final, Native, Private)
// Parameters:
// class FName                             InQteId                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInResult                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_Grapple::OnQTECompleted(class FName InQteId, bool bInResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnQTECompleted");

	Params::PhxAIGameplayAbility_Grapple_OnQTECompleted Parms{};

	Parms.InQteId = InQteId;
	Parms.bInResult = bInResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnQTEFailed
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnQTEFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnQTEFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnQTESuccess
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnQTESuccess()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnQTESuccess");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnStruggleBegin
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnStruggleBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnStruggleBegin");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnTargetEarlyExit
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnTargetEarlyExit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnTargetEarlyExit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnTargetEnteredPuppetState
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    TargetCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrappledPuppetState*             TargetGrappledPuppetState                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_Grapple::OnTargetEnteredPuppetState(class APhxCharacter* TargetCharacter, class UGrappledPuppetState* TargetGrappledPuppetState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnTargetEnteredPuppetState");

	Params::PhxAIGameplayAbility_Grapple_OnTargetEnteredPuppetState Parms{};

	Parms.TargetCharacter = TargetCharacter;
	Parms.TargetGrappledPuppetState = TargetGrappledPuppetState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnTargetExitedPuppetState
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    TargetCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrappledPuppetState*             TargetGrappledPuppetState                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIGameplayAbility_Grapple::OnTargetExitedPuppetState(class APhxCharacter* TargetCharacter, class UGrappledPuppetState* TargetGrappledPuppetState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnTargetExitedPuppetState");

	Params::PhxAIGameplayAbility_Grapple_OnTargetExitedPuppetState Parms{};

	Parms.TargetCharacter = TargetCharacter;
	Parms.TargetGrappledPuppetState = TargetGrappledPuppetState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.OnTargetFailToBeGrappled
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::OnTargetFailToBeGrappled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "OnTargetFailToBeGrappled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.SetupPairedKillSequence
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::SetupPairedKillSequence()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "SetupPairedKillSequence");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Grapple.TakeStruggleDamage
// (Final, Native, Private)

void UPhxAIGameplayAbility_Grapple::TakeStruggleDamage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Grapple", "TakeStruggleDamage");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Mutate.Mutate
// (Final, Native, Protected)

void UPhxAIGameplayAbility_Mutate::Mutate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Mutate", "Mutate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_Mutate.OnMutationAnimationCompleted
// (Final, Native, Protected)

void UPhxAIGameplayAbility_Mutate::OnMutationAnimationCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_Mutate", "OnMutationAnimationCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventTestActor.OnScriptedEventFinished
// (Final, Native, Public)

void APhxScriptedEventTestActor::OnScriptedEventFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventTestActor", "OnScriptedEventFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIGameplayAbility_SelfDestructAttack.KillCharacter
// (Final, Native, Private)

void UPhxAIGameplayAbility_SelfDestructAttack::KillCharacter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIGameplayAbility_SelfDestructAttack", "KillCharacter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPrinterHologram.CreateHologramMaterialForAllSlots
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UMaterialInstance*                Distortion                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstance*                Phantom                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPrinterHologram::CreateHologramMaterialForAllSlots(class UMaterialInstance* Distortion, class UMaterialInstance* Phantom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "CreateHologramMaterialForAllSlots");

	Params::PhxPrinterHologram_CreateHologramMaterialForAllSlots Parms{};

	Parms.Distortion = Distortion;
	Parms.Phantom = Phantom;

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


// Function Phoenix.PhxPrinterHologram.CreateMaterialForSlot
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseHologramMaterial                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPrinterHologram::CreateMaterialForSlot(int32 SlotIndex, bool bUseHologramMaterial)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "CreateMaterialForSlot");

	Params::PhxPrinterHologram_CreateMaterialForSlot Parms{};

	Parms.SlotIndex = SlotIndex;
	Parms.bUseHologramMaterial = bUseHologramMaterial;

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


// Function Phoenix.PhxPrinterHologram.HideHologram
// (Event, Public, BlueprintCallable, BlueprintEvent)

void APhxPrinterHologram::HideHologram()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "HideHologram");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrinterHologram.PrepareHologramForWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TSubclassOf<class AWeapon>        WeaponClass                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPrinterHologram::PrepareHologramForWeapon(const TSubclassOf<class AWeapon> WeaponClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "PrepareHologramForWeapon");

	Params::PhxPrinterHologram_PrepareHologramForWeapon Parms{};

	Parms.WeaponClass = WeaponClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPrinterHologram.SetSkeletalMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMesh*                    SkeletalMesh                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPrinterHologram::SetSkeletalMesh(class USkeletalMesh* SkeletalMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "SetSkeletalMesh");

	Params::PhxPrinterHologram_SetSkeletalMesh Parms{};

	Parms.SkeletalMesh = SkeletalMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPrinterHologram.SetStaticMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UStaticMesh*                      StaticMesh                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPrinterHologram::SetStaticMesh(class UStaticMesh* StaticMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "SetStaticMesh");

	Params::PhxPrinterHologram_SetStaticMesh Parms{};

	Parms.StaticMesh = StaticMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPrinterHologram.ShowHologram
// (Event, Public, BlueprintCallable, BlueprintEvent)

void APhxPrinterHologram::ShowHologram()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "ShowHologram");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrinterHologram.UpdatePrintHeadHeightParam
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   Height                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPrinterHologram::UpdatePrintHeadHeightParam(float Height)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrinterHologram", "UpdatePrintHeadHeightParam");

	Params::PhxPrinterHologram_UpdatePrintHeadHeightParam Parms{};

	Parms.Height = Height;

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


// Function Phoenix.PhxPushableInterface.CanReleasePushable
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IPhxPushableInterface::CanReleasePushable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxPushableInterface", "CanReleasePushable");

	Params::PhxPushableInterface_CanReleasePushable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPushableInterface.OnPushableGrabbed
// (Native, Event, Public, BlueprintEvent)

void IPhxPushableInterface::OnPushableGrabbed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxPushableInterface", "OnPushableGrabbed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPushableInterface.OnPushableReleased
// (Native, Event, Public, BlueprintEvent)

void IPhxPushableInterface::OnPushableReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxPushableInterface", "OnPushableReleased");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleGrateDoor.OnGrateFinishedOpening
// (Event, Protected, BlueprintEvent)

void APhxPuzzleGrateDoor::OnGrateFinishedOpening()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleGrateDoor", "OnGrateFinishedOpening");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPuzzleGrateDoor.OnGrateStartingToOpen
// (Event, Protected, BlueprintEvent)

void APhxPuzzleGrateDoor::OnGrateStartingToOpen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleGrateDoor", "OnGrateStartingToOpen");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPuzzleGrateDoor.OpenGrate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInstant                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPuzzleGrateDoor::OpenGrate(bool bInstant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleGrateDoor", "OpenGrate");

	Params::PhxPuzzleGrateDoor_OpenGrate Parms{};

	Parms.bInstant = bInstant;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPuzzleGrateDoor.ResetGrate
// (Final, Native, Public, BlueprintCallable)

void APhxPuzzleGrateDoor::ResetGrate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPuzzleGrateDoor", "ResetGrate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIMotionComponent.SetMotionTagOverride
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    InSource                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InPriority                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              InMotionTag                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InAnalogMovementInputSize                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIMotionComponent::SetMotionTagOverride(const class UObject* InSource, float InPriority, const struct FGameplayTag& InMotionTag, float InAnalogMovementInputSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIMotionComponent", "SetMotionTagOverride");

	Params::PhxAIMotionComponent_SetMotionTagOverride Parms{};

	Parms.InSource = InSource;
	Parms.InPriority = InPriority;
	Parms.InMotionTag = std::move(InMotionTag);
	Parms.InAnalogMovementInputSize = InAnalogMovementInputSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIOffensiveActionsComponent.OnDeath
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAIOffensiveActionsComponent::OnDeath(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIOffensiveActionsComponent", "OnDeath");

	Params::PhxAIOffensiveActionsComponent_OnDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIOffensiveActionsComponent.RequestCameraCutKill
// (Final, Native, Public, HasDefaults)
// Parameters:
// class AWeapon*                          Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxMeleeAttackDefinition*        Attack                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                ContextTransform                                       (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UPhxAIOffensiveActionsComponent::RequestCameraCutKill(class AWeapon* Weapon, class UPhxMeleeAttackDefinition* Attack, class AActor* TargetActor, const struct FTransform& ContextTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIOffensiveActionsComponent", "RequestCameraCutKill");

	Params::PhxAIOffensiveActionsComponent_RequestCameraCutKill Parms{};

	Parms.Weapon = Weapon;
	Parms.Attack = Attack;
	Parms.TargetActor = TargetActor;
	Parms.ContextTransform = std::move(ContextTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAIProp_BlueprintBase.OnPropTriggered
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           Triggerer                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxAIProp_BlueprintBase::OnPropTriggered(class AActor* Triggerer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAIProp_BlueprintBase", "OnPropTriggered");

	Params::PhxAIProp_BlueprintBase_OnPropTriggered Parms{};

	Parms.Triggerer = Triggerer;

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


// Function Phoenix.PhxMemoryBudgetMeterManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxMemoryBudgetMeterManager*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxMemoryBudgetMeterManager* UPhxMemoryBudgetMeterManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxMemoryBudgetMeterManager", "Get");

	Params::PhxMemoryBudgetMeterManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMemoryBudgetMeterManager.SetMemoryBudgetMeterVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Visibility                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMemoryBudgetMeterManager::SetMemoryBudgetMeterVisibility(ESlateVisibility Visibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMemoryBudgetMeterManager", "SetMemoryBudgetMeterVisibility");

	Params::PhxMemoryBudgetMeterManager_SetMemoryBudgetMeterVisibility Parms{};

	Parms.Visibility = Visibility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMemoryBudgetMeterManager.GetIsMemoryBudgetMeterVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxMemoryBudgetMeterManager::GetIsMemoryBudgetMeterVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMemoryBudgetMeterManager", "GetIsMemoryBudgetMeterVisible");

	Params::PhxMemoryBudgetMeterManager_GetIsMemoryBudgetMeterVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxShipCockpit.RegisterPilotCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxPlayerCharacter*              PilotCharacter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxShipCockpit::RegisterPilotCharacter(class APhxPlayerCharacter* PilotCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxShipCockpit", "RegisterPilotCharacter");

	Params::PhxShipCockpit_RegisterPilotCharacter Parms{};

	Parms.PilotCharacter = PilotCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxShipCockpit.SetPilotingActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewPilotingActive                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxShipCockpit::SetPilotingActive(bool bNewPilotingActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxShipCockpit", "SetPilotingActive");

	Params::PhxShipCockpit_SetPilotingActive Parms{};

	Parms.bNewPilotingActive = bNewPilotingActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSkeletalMeshComponent.DebugDrawJointConstraintViolations
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   StretchTolerance                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DrawDuration                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawSkeleton                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLogMessage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSkeletalMeshComponent::DebugDrawJointConstraintViolations(float StretchTolerance, float DrawDuration, bool bDrawSkeleton, bool bLogMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSkeletalMeshComponent", "DebugDrawJointConstraintViolations");

	Params::PhxSkeletalMeshComponent_DebugDrawJointConstraintViolations Parms{};

	Parms.StretchTolerance = StretchTolerance;
	Parms.DrawDuration = DrawDuration;
	Parms.bDrawSkeleton = bDrawSkeleton;
	Parms.bLogMessage = bLogMessage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSkeletalMeshComponent.EnforceRagdollConstraints
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bLogMessage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSkeletalMeshComponent::EnforceRagdollConstraints(bool bLogMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSkeletalMeshComponent", "EnforceRagdollConstraints");

	Params::PhxSkeletalMeshComponent_EnforceRagdollConstraints Parms{};

	Parms.bLogMessage = bLogMessage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSkeletalMeshComponent.PutAllRigidBodiesToSleep
// (Native, Public, BlueprintCallable)

void UPhxSkeletalMeshComponent::PutAllRigidBodiesToSleep()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSkeletalMeshComponent", "PutAllRigidBodiesToSleep");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSkeletalMeshComponent.GetCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCharacter* UPhxSkeletalMeshComponent::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSkeletalMeshComponent", "GetCharacter");

	Params::PhxSkeletalMeshComponent_GetCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSlider.ChangeValue
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bIncrement                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSlider::ChangeValue(bool bIncrement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSlider", "ChangeValue");

	Params::PhxSlider_ChangeValue Parms{};

	Parms.bIncrement = bIncrement;

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


// Function Phoenix.PhxSlider.SetLabel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxSlider::SetLabel(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSlider", "SetLabel");

	Params::PhxSlider_SetLabel Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSlider.SetSliderValue
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBroadcast                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSlider::SetSliderValue(float InValue, bool bBroadcast)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSlider", "SetSliderValue");

	Params::PhxSlider_SetSliderValue Parms{};

	Parms.InValue = InValue;
	Parms.bBroadcast = bBroadcast;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSlider.GetSliderValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxSlider::GetSliderValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSlider", "GetSliderValue");

	Params::PhxSlider_GetSliderValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMine.Explode
// (Final, Native, Protected, BlueprintCallable)

void APhxMine::Explode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMine", "Explode");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMine.HandleTakeAnyDamage
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMine::HandleTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMine", "HandleTakeAnyDamage");

	Params::PhxMine_HandleTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMine.OnProximityBoxBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxMine::OnProximityBoxBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMine", "OnProximityBoxBeginOverlap");

	Params::PhxMine_OnProximityBoxBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAISensor_Damage.HandleTakeAnyDamage
// (Final, Native, Private)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAISensor_Damage::HandleTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAISensor_Damage", "HandleTakeAnyDamage");

	Params::PhxAISensor_Damage_HandleTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.AddActivePerk
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxRiotModePerkType                    PerkType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhoenixRiotModeSubSytem::AddActivePerk(EPhxRiotModePerkType PerkType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "AddActivePerk");

	Params::PhoenixRiotModeSubSytem_AddActivePerk Parms{};

	Parms.PerkType = PerkType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.CheckForDismemberments
// (Final, Native, Public, HasOutParams)
// Parameters:
// const TArray<EPhxBodyPartType>&         BodyPartTypes                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           Instigator                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OwningChacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::CheckForDismemberments(const TArray<EPhxBodyPartType>& BodyPartTypes, class AActor* Instigator, class AActor* OwningChacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "CheckForDismemberments");

	Params::PhoenixRiotModeSubSytem_CheckForDismemberments Parms{};

	Parms.BodyPartTypes = std::move(BodyPartTypes);
	Parms.Instigator = Instigator;
	Parms.OwningChacter = OwningChacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnCharacterDiedFromGRPCollision
// (Final, Native, Public)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnCharacterDiedFromGRPCollision(const class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnCharacterDiedFromGRPCollision");

	Params::PhoenixRiotModeSubSytem_OnCharacterDiedFromGRPCollision Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnEnemyDied
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           AIGameStateManager                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnEnemyDied(class UPhxAIGameStateManager* AIGameStateManager, class APhxAICharacter* Enemy, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnEnemyDied");

	Params::PhoenixRiotModeSubSytem_OnEnemyDied Parms{};

	Parms.AIGameStateManager = AIGameStateManager;
	Parms.Enemy = Enemy;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnEnemySpawned
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           AIGameStateManager                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnEnemySpawned(class UPhxAIGameStateManager* AIGameStateManager, class APhxAICharacter* Enemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnEnemySpawned");

	Params::PhoenixRiotModeSubSytem_OnEnemySpawned Parms{};

	Parms.AIGameStateManager = AIGameStateManager;
	Parms.Enemy = Enemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnHordeWaveCompleted
// (Final, Native, Public)
// Parameters:
// class APhxAIHordeEncounterGroup*        InHordeEncounterGroup                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   HordeWaveIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnHordeWaveCompleted(class APhxAIHordeEncounterGroup* InHordeEncounterGroup, int32 HordeWaveIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnHordeWaveCompleted");

	Params::PhoenixRiotModeSubSytem_OnHordeWaveCompleted Parms{};

	Parms.InHordeEncounterGroup = InHordeEncounterGroup;
	Parms.HordeWaveIndex = HordeWaveIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnItemPurchasedFromLootCrate
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32                             CreditsSpent                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ItemTier                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnItemPurchasedFromLootCrate(const int32 CreditsSpent, const class FName& ItemName, const int32 ItemTier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnItemPurchasedFromLootCrate");

	Params::PhoenixRiotModeSubSytem_OnItemPurchasedFromLootCrate Parms{};

	Parms.CreditsSpent = CreditsSpent;
	Parms.ItemName = ItemName;
	Parms.ItemTier = ItemTier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnNewHitRecorded
// (Final, Native, Public, HasOutParams)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxCharacterHealthComponent*HealthComponent                                        (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnNewHitRecorded(class APhxCharacter* Character, const class UPhxCharacterHealthComponent* HealthComponent, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnNewHitRecorded");

	Params::PhoenixRiotModeSubSytem_OnNewHitRecorded Parms{};

	Parms.Character = Character;
	Parms.HealthComponent = HealthComponent;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerDefensiveActionInitiated
// (Final, Native, Public, HasOutParams)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnPlayerDefensiveActionInitiated(EReactionType ReactionType, EDefensiveReactDirection ReactionDir, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnPlayerDefensiveActionInitiated");

	Params::PhoenixRiotModeSubSytem_OnPlayerDefensiveActionInitiated Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerDied
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnPlayerDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnPlayerDied");

	Params::PhoenixRiotModeSubSytem_OnPlayerDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerInventoryChanged
// (Final, Native, Public, HasOutParams)
// Parameters:
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnPlayerInventoryChanged(const class FName& ItemName, int32 Quantity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnPlayerInventoryChanged");

	Params::PhoenixRiotModeSubSytem_OnPlayerInventoryChanged Parms{};

	Parms.ItemName = ItemName;
	Parms.Quantity = Quantity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerItemConsumed
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnPlayerItemConsumed(const struct FItemData& ItemData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnPlayerItemConsumed");

	Params::PhoenixRiotModeSubSytem_OnPlayerItemConsumed Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnPlayerTraversalInitiated
// (Final, Native, Public, HasOutParams)
// Parameters:
// class APhxPlayerCharacter*              Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     AbilityTags                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnPlayerTraversalInitiated(class APhxPlayerCharacter* Player, const struct FGameplayTagContainer& AbilityTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnPlayerTraversalInitiated");

	Params::PhoenixRiotModeSubSytem_OnPlayerTraversalInitiated Parms{};

	Parms.Player = Player;
	Parms.AbilityTags = std::move(AbilityTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.OnSafeRoomExited
// (Final, Native, Public)
// Parameters:
// int32                                   SafeRoomIndex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::OnSafeRoomExited(int32 SafeRoomIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "OnSafeRoomExited");

	Params::PhoenixRiotModeSubSytem_OnSafeRoomExited Parms{};

	Parms.SafeRoomIndex = SafeRoomIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.RecordRiotModeGameplayStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EPhxRiotModeStatType              StatType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              CharacterTag                                           (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::RecordRiotModeGameplayStat(const EPhxRiotModeStatType StatType, const struct FGameplayTag& CharacterTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "RecordRiotModeGameplayStat");

	Params::PhoenixRiotModeSubSytem_RecordRiotModeGameplayStat Parms{};

	Parms.StatType = StatType;
	Parms.CharacterTag = std::move(CharacterTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.RemoveActivePerk
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxRiotModePerkType                    PerkType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::RemoveActivePerk(EPhxRiotModePerkType PerkType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "RemoveActivePerk");

	Params::PhoenixRiotModeSubSytem_RemoveActivePerk Parms{};

	Parms.PerkType = PerkType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.SetCurrentWave
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   WaveNumber                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::SetCurrentWave(int32 WaveNumber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "SetCurrentWave");

	Params::PhoenixRiotModeSubSytem_SetCurrentWave Parms{};

	Parms.WaveNumber = WaveNumber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.UnlockModifier
// (Final, Native, Public, BlueprintCallable)

void UPhoenixRiotModeSubSytem::UnlockModifier()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "UnlockModifier");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.UnlockPerk
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxRiotModePerkType                    PerkType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhoenixRiotModeSubSytem::UnlockPerk(EPhxRiotModePerkType PerkType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "UnlockPerk");

	Params::PhoenixRiotModeSubSytem_UnlockPerk Parms{};

	Parms.PerkType = PerkType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhoenixRiotModeSubSytem.ActiveModifierTimeRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhoenixRiotModeSubSytem::ActiveModifierTimeRemaining() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "ActiveModifierTimeRemaining");

	Params::PhoenixRiotModeSubSytem_ActiveModifierTimeRemaining Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetCurrentComboTimeRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const float UPhoenixRiotModeSubSytem::GetCurrentComboTimeRemaining() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetCurrentComboTimeRemaining");

	Params::PhoenixRiotModeSubSytem_GetCurrentComboTimeRemaining Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetCurrentComboValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const float UPhoenixRiotModeSubSytem::GetCurrentComboValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetCurrentComboValue");

	Params::PhoenixRiotModeSubSytem_GetCurrentComboValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetCurrentWave
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhoenixRiotModeSubSytem::GetCurrentWave() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetCurrentWave");

	Params::PhoenixRiotModeSubSytem_GetCurrentWave Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetMaxComboTimer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const float UPhoenixRiotModeSubSytem::GetMaxComboTimer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetMaxComboTimer");

	Params::PhoenixRiotModeSubSytem_GetMaxComboTimer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetMaxComboValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const float UPhoenixRiotModeSubSytem::GetMaxComboValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetMaxComboValue");

	Params::PhoenixRiotModeSubSytem_GetMaxComboValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetPointValueForStat
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              CharacterTag                                           (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EPhxRiotModeStatType              StatType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const int32 UPhoenixRiotModeSubSytem::GetPointValueForStat(const struct FGameplayTag& CharacterTag, const EPhxRiotModeStatType StatType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetPointValueForStat");

	Params::PhoenixRiotModeSubSytem_GetPointValueForStat Parms{};

	Parms.CharacterTag = std::move(CharacterTag);
	Parms.StatType = StatType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetStatCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EPhxRiotModeStatType              StatType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const int32 UPhoenixRiotModeSubSytem::GetStatCount(const EPhxRiotModeStatType StatType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetStatCount");

	Params::PhoenixRiotModeSubSytem_GetStatCount Parms{};

	Parms.StatType = StatType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetStatRecordForCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              CharacterTag                                           (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EPhxRiotModeStatType              StatType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRiotModeStatRecord        ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FRiotModeStatRecord UPhoenixRiotModeSubSytem::GetStatRecordForCharacter(const struct FGameplayTag& CharacterTag, const EPhxRiotModeStatType StatType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetStatRecordForCharacter");

	Params::PhoenixRiotModeSubSytem_GetStatRecordForCharacter Parms{};

	Parms.CharacterTag = std::move(CharacterTag);
	Parms.StatType = StatType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetStatTotalCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const int32 UPhoenixRiotModeSubSytem::GetStatTotalCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetStatTotalCount");

	Params::PhoenixRiotModeSubSytem_GetStatTotalCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetStatTotalPoints
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EPhxRiotModeStatType              StatType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const int32 UPhoenixRiotModeSubSytem::GetStatTotalPoints(const EPhxRiotModeStatType StatType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetStatTotalPoints");

	Params::PhoenixRiotModeSubSytem_GetStatTotalPoints Parms{};

	Parms.StatType = StatType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetTableRowDataForStat
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              CharacterTag                                           (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EPhxRiotModeStatType              StatType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRiotModeStatDataRow       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FRiotModeStatDataRow UPhoenixRiotModeSubSytem::GetTableRowDataForStat(const struct FGameplayTag& CharacterTag, const EPhxRiotModeStatType StatType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetTableRowDataForStat");

	Params::PhoenixRiotModeSubSytem_GetTableRowDataForStat Parms{};

	Parms.CharacterTag = std::move(CharacterTag);
	Parms.StatType = StatType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.GetTotalPoints
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const int32 UPhoenixRiotModeSubSytem::GetTotalPoints() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "GetTotalPoints");

	Params::PhoenixRiotModeSubSytem_GetTotalPoints Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.IsModifierAvailable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const bool UPhoenixRiotModeSubSytem::IsModifierAvailable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "IsModifierAvailable");

	Params::PhoenixRiotModeSubSytem_IsModifierAvailable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.IsPerkActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxRiotModePerkType                    PerkType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhoenixRiotModeSubSytem::IsPerkActive(EPhxRiotModePerkType PerkType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "IsPerkActive");

	Params::PhoenixRiotModeSubSytem_IsPerkActive Parms{};

	Parms.PerkType = PerkType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.IsPerkUnlocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxRiotModePerkType                    PerkType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhoenixRiotModeSubSytem::IsPerkUnlocked(EPhxRiotModePerkType PerkType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "IsPerkUnlocked");

	Params::PhoenixRiotModeSubSytem_IsPerkUnlocked Parms{};

	Parms.PerkType = PerkType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhoenixRiotModeSubSytem.ScoreNeededForModifier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhoenixRiotModeSubSytem::ScoreNeededForModifier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhoenixRiotModeSubSytem", "ScoreNeededForModifier");

	Params::PhoenixRiotModeSubSytem_ScoreNeededForModifier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMeleeAttackTester.BeginAttackTester
// (Final, Native, Public, BlueprintCallable)

void APhxMeleeAttackTester::BeginAttackTester()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMeleeAttackTester", "BeginAttackTester");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMeleeAttackTester.GetCurrentAttackStage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EMeleeAttackTesterStage                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMeleeAttackTesterStage APhxMeleeAttackTester::GetCurrentAttackStage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMeleeAttackTester", "GetCurrentAttackStage");

	Params::PhxMeleeAttackTester_GetCurrentAttackStage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetGraphTitle
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   GraphIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetGraphTitle(int32 GraphIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetGraphTitle");

	Params::PhxAllocationTrackerWidget_GetGraphTitle Parms{};

	Parms.GraphIndex = GraphIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetMessage
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   MessageIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetMessage(int32 MessageIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetMessage");

	Params::PhxAllocationTrackerWidget_GetMessage Parms{};

	Parms.MessageIndex = MessageIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetPageTitle
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetPageTitle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetPageTitle");

	Params::PhxAllocationTrackerWidget_GetPageTitle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetXMaxLabel
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   GraphIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetXMaxLabel(int32 GraphIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetXMaxLabel");

	Params::PhxAllocationTrackerWidget_GetXMaxLabel Parms{};

	Parms.GraphIndex = GraphIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetXMinLabel
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   GraphIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetXMinLabel(int32 GraphIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetXMinLabel");

	Params::PhxAllocationTrackerWidget_GetXMinLabel Parms{};

	Parms.GraphIndex = GraphIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetYCurrentLabel
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   GraphIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetYCurrentLabel(int32 GraphIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetYCurrentLabel");

	Params::PhxAllocationTrackerWidget_GetYCurrentLabel Parms{};

	Parms.GraphIndex = GraphIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetYMaxLabel
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   GraphIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetYMaxLabel(int32 GraphIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetYMaxLabel");

	Params::PhxAllocationTrackerWidget_GetYMaxLabel Parms{};

	Parms.GraphIndex = GraphIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.GetYMinLabel
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   GraphIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxAllocationTrackerWidget::GetYMinLabel(int32 GraphIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "GetYMinLabel");

	Params::PhxAllocationTrackerWidget_GetYMinLabel Parms{};

	Parms.GraphIndex = GraphIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAllocationTrackerWidget.IncrementPageColumn
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAllocationTrackerWidget::IncrementPageColumn(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "IncrementPageColumn");

	Params::PhxAllocationTrackerWidget_IncrementPageColumn Parms{};

	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAllocationTrackerWidget.IncrementPageRow
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAllocationTrackerWidget::IncrementPageRow(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAllocationTrackerWidget", "IncrementPageRow");

	Params::PhxAllocationTrackerWidget_IncrementPageRow Parms{};

	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAmbientSound.StartAmbientSound
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void APhxAmbientSound::StartAmbientSound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmbientSound", "StartAmbientSound");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAmbientSound.StopAmbientSound
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void APhxAmbientSound::StopAmbientSound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmbientSound", "StopAmbientSound");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAmmoComponent.UpdateAmmoDisplay
// (Final, Native, Public)
// Parameters:
// int32                                   ClipSize                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAmmoComponent::UpdateAmmoDisplay(int32 ClipSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmmoComponent", "UpdateAmmoDisplay");

	Params::PhxAmmoComponent_UpdateAmmoDisplay Parms{};

	Parms.ClipSize = ClipSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAmmoComponent.GetAmmoInventoryName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UPhxAmmoComponent::GetAmmoInventoryName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmmoComponent", "GetAmmoInventoryName");

	Params::PhxAmmoComponent_GetAmmoInventoryName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAmmoComponent.GetCurrentAmmoInClip
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxAmmoComponent::GetCurrentAmmoInClip() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmmoComponent", "GetCurrentAmmoInClip");

	Params::PhxAmmoComponent_GetCurrentAmmoInClip Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAmmoComponent.GetCurrentAmmoInReserve
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxAmmoComponent::GetCurrentAmmoInReserve() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmmoComponent", "GetCurrentAmmoInReserve");

	Params::PhxAmmoComponent_GetCurrentAmmoInReserve Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAmmoComponent.GetTotalRemainingAmmo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxAmmoComponent::GetTotalRemainingAmmo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAmmoComponent", "GetTotalRemainingAmmo");

	Params::PhxAmmoComponent_GetTotalRemainingAmmo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifySettings.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UPhxSoundAnimNotifySettingsData*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSoundAnimNotifySettingsData* UPhxSoundAnimNotifySettings::Get()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifySettings", "Get");

	Params::PhxSoundAnimNotifySettings_Get Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundEndOfEventProxy.PlaySoundAndContinue
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ESoundSource                            Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSoundComponent*               SoundComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AdditionalDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSoundEndOfEventProxy*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSoundEndOfEventProxy* UPhxSoundEndOfEventProxy::PlaySoundAndContinue(const class UObject* WorldContextObject, ESoundSource Source, class UPhxSoundComponent* SoundComp, class UAkAudioEvent* Event, float AdditionalDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundEndOfEventProxy", "PlaySoundAndContinue");

	Params::PhxSoundEndOfEventProxy_PlaySoundAndContinue Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Source = Source;
	Parms.SoundComp = SoundComp;
	Parms.Event = Event;
	Parms.AdditionalDelay = AdditionalDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLiteWeaponSkinComponent.OnWeaponSkinChanged
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayTag&              InWeaponTag                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLiteWeaponSkinComponent::OnWeaponSkinChanged(const struct FGameplayTag& InWeaponTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLiteWeaponSkinComponent", "OnWeaponSkinChanged");

	Params::PhxLiteWeaponSkinComponent_OnWeaponSkinChanged Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLookAtComponent.BeginTriggerLookAt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLookAtComponent::BeginTriggerLookAt(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLookAtComponent", "BeginTriggerLookAt");

	Params::PhxLookAtComponent_BeginTriggerLookAt Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLookAtComponent.DisableLookAt
// (Final, Native, Public, BlueprintCallable)

void UPhxLookAtComponent::DisableLookAt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLookAtComponent", "DisableLookAt");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLookAtComponent.EnableLookAt
// (Final, Native, Public, BlueprintCallable)

void UPhxLookAtComponent::EnableLookAt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLookAtComponent", "EnableLookAt");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLookAtComponent.EndTriggerLookAt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLookAtComponent::EndTriggerLookAt(class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLookAtComponent", "EndTriggerLookAt");

	Params::PhxLookAtComponent_EndTriggerLookAt Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLookAtComponent.SetLookIntensity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             Intensity                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLookAtComponent::SetLookIntensity(const float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLookAtComponent", "SetLookIntensity");

	Params::PhxLookAtComponent_SetLookIntensity Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLootDropList.GetDropRateData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UDataTable*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UDataTable* UPhxLootDropList::GetDropRateData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLootDropList", "GetDropRateData");

	Params::PhxLootDropList_GetDropRateData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAnimNotifyState_CheckEnvironmentalHazard.OnMoveBlockedBy
// (Final, Native, Public, HasOutParams, Const)
// Parameters:
// class APhxAICharacter*                  Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Impact                                                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxAnimNotifyState_CheckEnvironmentalHazard::OnMoveBlockedBy(class APhxAICharacter* Character, const struct FHitResult& Impact) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAnimNotifyState_CheckEnvironmentalHazard", "OnMoveBlockedBy");

	Params::PhxAnimNotifyState_CheckEnvironmentalHazard_OnMoveBlockedBy Parms{};

	Parms.Character = Character;
	Parms.Impact = std::move(Impact);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAnimNotifyState_PlaySound.OnAnimsPaused
// (Final, Native, Private, Const)
// Parameters:
// class UPhxSkeletalMeshComponent*        MeshComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAnimNotifyState_PlaySound::OnAnimsPaused(class UPhxSkeletalMeshComponent* MeshComp) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAnimNotifyState_PlaySound", "OnAnimsPaused");

	Params::PhxAnimNotifyState_PlaySound_OnAnimsPaused Parms{};

	Parms.MeshComp = MeshComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAnimNotifyState_PlaySound.OnSoundEnded
// (Final, Native, Private, Const)
// Parameters:
// EAkCallbackType                         CallbackType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  CallbackInfo                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAnimNotifyState_PlaySound::OnSoundEnded(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAnimNotifyState_PlaySound", "OnSoundEnded");

	Params::PhxAnimNotifyState_PlaySound_OnSoundEnded Parms{};

	Parms.CallbackType = CallbackType;
	Parms.CallbackInfo = CallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxAssetBudgetMeterManager*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAssetBudgetMeterManager* UPhxAssetBudgetMeterManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAssetBudgetMeterManager", "Get");

	Params::PhxAssetBudgetMeterManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetBudgetMeterManager.ResetAssetBudgetMeterAvgTiming
// (Final, Native, Public, BlueprintCallable)

void UPhxAssetBudgetMeterManager::ResetAssetBudgetMeterAvgTiming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "ResetAssetBudgetMeterAvgTiming");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.SetAssetBudgetMeterDebugVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Visibility                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterManager::SetAssetBudgetMeterDebugVisibility(ESlateVisibility Visibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "SetAssetBudgetMeterDebugVisibility");

	Params::PhxAssetBudgetMeterManager_SetAssetBudgetMeterDebugVisibility Parms{};

	Parms.Visibility = Visibility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.SetAssetBudgetMeterVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Visibility                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterManager::SetAssetBudgetMeterVisibility(ESlateVisibility Visibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "SetAssetBudgetMeterVisibility");

	Params::PhxAssetBudgetMeterManager_SetAssetBudgetMeterVisibility Parms{};

	Parms.Visibility = Visibility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.SetBenchmarkMetrics
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterManager::SetBenchmarkMetrics(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "SetBenchmarkMetrics");

	Params::PhxAssetBudgetMeterManager_SetBenchmarkMetrics Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.SetupAssetBudgetMeter
// (Final, Native, Public, BlueprintCallable)

void UPhxAssetBudgetMeterManager::SetupAssetBudgetMeter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "SetupAssetBudgetMeter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.SetUseBenchmarkMetricsOnVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterManager::SetUseBenchmarkMetricsOnVisible(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "SetUseBenchmarkMetricsOnVisible");

	Params::PhxAssetBudgetMeterManager_SetUseBenchmarkMetricsOnVisible Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.UpdateStats
// (Final, Native, Public)

void UPhxAssetBudgetMeterManager::UpdateStats()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "UpdateStats");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterManager.GetAssetBudgetMeterWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxAssetBudgetMeterWidget*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxAssetBudgetMeterWidget* UPhxAssetBudgetMeterManager::GetAssetBudgetMeterWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "GetAssetBudgetMeterWidget");

	Params::PhxAssetBudgetMeterManager_GetAssetBudgetMeterWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetBudgetMeterManager.IsAssetBudgetMeterDebugVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAssetBudgetMeterManager::IsAssetBudgetMeterDebugVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "IsAssetBudgetMeterDebugVisible");

	Params::PhxAssetBudgetMeterManager_IsAssetBudgetMeterDebugVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetBudgetMeterManager.IsAssetBudgetMeterVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAssetBudgetMeterManager::IsAssetBudgetMeterVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "IsAssetBudgetMeterVisible");

	Params::PhxAssetBudgetMeterManager_IsAssetBudgetMeterVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetBudgetMeterManager.IsUsingBenchmarkMetricsOnVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAssetBudgetMeterManager::IsUsingBenchmarkMetricsOnVisible() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterManager", "IsUsingBenchmarkMetricsOnVisible");

	Params::PhxAssetBudgetMeterManager_IsUsingBenchmarkMetricsOnVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.AddGroupWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxAssetBudgetGroupWidget*       Widget                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterWidget::AddGroupWidget(class UPhxAssetBudgetGroupWidget* Widget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "AddGroupWidget");

	Params::PhxAssetBudgetMeterWidget_AddGroupWidget Parms{};

	Parms.Widget = Widget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.AddSubGroupWidgets
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxAssetBudgetGroup                    StatGroup                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UPhxAssetBudgetGroupWidget*>&SubWidgets                                             (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterWidget::AddSubGroupWidgets(EPhxAssetBudgetGroup StatGroup, const TArray<class UPhxAssetBudgetGroupWidget*>& SubWidgets)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "AddSubGroupWidgets");

	Params::PhxAssetBudgetMeterWidget_AddSubGroupWidgets Parms{};

	Parms.StatGroup = StatGroup;
	Parms.SubWidgets = std::move(SubWidgets);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.InitializeGroupWidgets
// (Final, Native, Public, BlueprintCallable)

void UPhxAssetBudgetMeterWidget::InitializeGroupWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "InitializeGroupWidgets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.IsDebugSectionVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxAssetBudgetMeterWidget::IsDebugSectionVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "IsDebugSectionVisible");

	Params::PhxAssetBudgetMeterWidget_IsDebugSectionVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.SetDebugSectionVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Vis                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterWidget::SetDebugSectionVisibility(ESlateVisibility Vis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "SetDebugSectionVisibility");

	Params::PhxAssetBudgetMeterWidget_SetDebugSectionVisibility Parms{};

	Parms.Vis = Vis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.SetDetailTimingVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Vis                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterWidget::SetDetailTimingVisibility(ESlateVisibility Vis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "SetDetailTimingVisibility");

	Params::PhxAssetBudgetMeterWidget_SetDetailTimingVisibility Parms{};

	Parms.Vis = Vis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.SetDrawsStatsVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility                        Vis                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterWidget::SetDrawsStatsVisibility(ESlateVisibility Vis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "SetDrawsStatsVisibility");

	Params::PhxAssetBudgetMeterWidget_SetDrawsStatsVisibility Parms{};

	Parms.Vis = Vis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAssetBudgetMeterWidget.SetSubGroupsVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Visible                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxAssetBudgetMeterWidget::SetSubGroupsVisibility(bool Visible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxAssetBudgetMeterWidget", "SetSubGroupsVisibility");

	Params::PhxAssetBudgetMeterWidget_SetSubGroupsVisibility Parms{};

	Parms.Visible = Visible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxAudioPhysicsManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAudioPhysicsManager*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxAudioPhysicsManager* APhxAudioPhysicsManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxAudioPhysicsManager", "Get");

	Params::PhxAudioPhysicsManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMuckVolume.OnVolumeBeginOverlap
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxMuckVolume::OnVolumeBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMuckVolume", "OnVolumeBeginOverlap");

	Params::PhxMuckVolume_OnVolumeBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMuckVolume.OnVolumeEndOverlap
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMuckVolume::OnVolumeEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMuckVolume", "OnVolumeEndOverlap");

	Params::PhxMuckVolume_OnVolumeEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBenchmark.BeginBenchmarking
// (Final, Native, Public, BlueprintCallable)

void APhxBenchmark::BeginBenchmarking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBenchmark", "BeginBenchmarking");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBio.IsDecrypted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxBio::IsDecrypted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBio", "IsDecrypted");

	Params::PhxBio_IsDecrypted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SplineInteraction.DidEnterInReverse
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAxis                                   SplineAxis                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USplineInteraction::DidEnterInReverse(EAxis SplineAxis) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineInteraction", "DidEnterInReverse");

	Params::SplineInteraction_DidEnterInReverse Parms{};

	Parms.SplineAxis = SplineAxis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SplineInteraction.GetInteractedComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInteractableComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInteractableComponent* USplineInteraction::GetInteractedComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineInteraction", "GetInteractedComponent");

	Params::SplineInteraction_GetInteractedComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGraphicSettingsListManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxGraphicSettingsListManager*   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxGraphicSettingsListManager* UPhxGraphicSettingsListManager::Get(const class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGraphicSettingsListManager", "Get");

	Params::PhxGraphicSettingsListManager_Get Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGraphicSettingsListManager.IsVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGraphicSettingsListManager::IsVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGraphicSettingsListManager", "IsVisible");

	Params::PhxGraphicSettingsListManager_IsVisible Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGraphicSettingsListManager.ToggleUI
// (Final, Native, Public, BlueprintCallable)

void UPhxGraphicSettingsListManager::ToggleUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGraphicSettingsListManager", "ToggleUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBlueprintAction_LoadScriptedEventCinematics.LoadScriptedEventCinematics
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxScriptedEventActor*           ScriptedEventActor                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxBlueprintAction_LoadScriptedEventCinematics*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxBlueprintAction_LoadScriptedEventCinematics* UPhxBlueprintAction_LoadScriptedEventCinematics::LoadScriptedEventCinematics(class APhxScriptedEventActor* ScriptedEventActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxBlueprintAction_LoadScriptedEventCinematics", "LoadScriptedEventCinematics");

	Params::PhxBlueprintAction_LoadScriptedEventCinematics_LoadScriptedEventCinematics Parms{};

	Parms.ScriptedEventActor = ScriptedEventActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxBlueprintAction_LoadScriptedEventCinematics.OnCinematicsLoaded
// (Final, Native, Private)

void UPhxBlueprintAction_LoadScriptedEventCinematics::OnCinematicsLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_LoadScriptedEventCinematics", "OnCinematicsLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBlueprintAction_MovementSpline_AlignToLocation.AlignLocationOffsetToWorldLocation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class APhxMovementSpline*               MovementSpline                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxBlueprintAction_MovementSpline_AlignToLocation*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxBlueprintAction_MovementSpline_AlignToLocation* UPhxBlueprintAction_MovementSpline_AlignToLocation::AlignLocationOffsetToWorldLocation(class APhxMovementSpline* MovementSpline, const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxBlueprintAction_MovementSpline_AlignToLocation", "AlignLocationOffsetToWorldLocation");

	Params::PhxBlueprintAction_MovementSpline_AlignToLocation_AlignLocationOffsetToWorldLocation Parms{};

	Parms.MovementSpline = MovementSpline;
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxBlueprintAction_MovementSpline_AlignToLocation.HandleAlignmentFinished
// (Final, Native, Private)

void UPhxBlueprintAction_MovementSpline_AlignToLocation::HandleAlignmentFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_MovementSpline_AlignToLocation", "HandleAlignmentFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBlueprintAction_SwapPlayerPawn.SwapPlayerPawn
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftClassPtr<class UClass>             NewCharacter                                           (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxBlueprintAction_SwapPlayerPawn*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxBlueprintAction_SwapPlayerPawn* UPhxBlueprintAction_SwapPlayerPawn::SwapPlayerPawn(class APlayerController* PlayerController, TSoftClassPtr<class UClass> NewCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxBlueprintAction_SwapPlayerPawn", "SwapPlayerPawn");

	Params::PhxBlueprintAction_SwapPlayerPawn_SwapPlayerPawn Parms{};

	Parms.PlayerController = PlayerController;
	Parms.NewCharacter = NewCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxBlueprintAction_SwapPlayerPawn.HandleCharacterClassLoaded
// (Final, Native, Private)

void UPhxBlueprintAction_SwapPlayerPawn::HandleCharacterClassLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBlueprintAction_SwapPlayerPawn", "HandleCharacterClassLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGrinderLocomotionComponent.EnableGrinderLocomotion
// (Final, Native, Public, BlueprintCallable)

void UPhxGrinderLocomotionComponent::EnableGrinderLocomotion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGrinderLocomotionComponent", "EnableGrinderLocomotion");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGrinderLocomotionComponent.InitializeGrinderLocomotion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<struct FRotatingGear>&     RotatingGears                                          (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxGrinderLocomotionComponent::InitializeGrinderLocomotion(const TArray<struct FRotatingGear>& RotatingGears)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGrinderLocomotionComponent", "InitializeGrinderLocomotion");

	Params::PhxGrinderLocomotionComponent_InitializeGrinderLocomotion Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLootProp.SpawnItem
// (Native, Public, BlueprintCallable)
// Parameters:
// class APhxPlayerCharacter*              Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSimulatePhysics                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLootProp::SpawnItem(class APhxPlayerCharacter* Character, bool bSimulatePhysics)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLootProp", "SpawnItem");

	Params::PhxLootProp_SpawnItem Parms{};

	Parms.Character = Character;
	Parms.bSimulatePhysics = bSimulatePhysics;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyDrop.OnEndMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyDrop::OnEndMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyDrop", "OnEndMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyDrop.OnWaitTaskFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyDrop::OnWaitTaskFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyDrop", "OnWaitTaskFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBreakableLootProp.BreakProp
// (Final, Native, Protected)
// Parameters:
// class APhxPlayerCharacter*              Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxBreakableLootProp::BreakProp(class APhxPlayerCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBreakableLootProp", "BreakProp");

	Params::PhxBreakableLootProp_BreakProp Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxBreakableLootProp.TakeDamage
// (Native, Protected, HasOutParams)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDamageEvent&              DamageEvent                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class AController*                      EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxBreakableLootProp::TakeDamage(float Damage, const struct FDamageEvent& DamageEvent, class AController* EventInstigator, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBreakableLootProp", "TakeDamage");

	Params::PhxBreakableLootProp_TakeDamage Parms{};

	Parms.Damage = Damage;
	Parms.DamageEvent = std::move(DamageEvent);
	Parms.EventInstigator = EventInstigator;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PuzzleTriggerableActor.OnTriggered_BP
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bOn                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APuzzleTriggerableActor::OnTriggered_BP(bool bOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PuzzleTriggerableActor", "OnTriggered_BP");

	Params::PuzzleTriggerableActor_OnTriggered_BP Parms{};

	Parms.bOn = bOn;

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


// Function Phoenix.PhxGameplayAbility_ShivHarvest.OnUnequipTagRemoved
// (Final, Native, Protected)

void UPhxGameplayAbility_ShivHarvest::OnUnequipTagRemoved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_ShivHarvest", "OnUnequipTagRemoved");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSInteractionWidget.DestroyIcon
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::DestroyIcon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "DestroyIcon");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.FuseRequiredNotify
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::FuseRequiredNotify()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "FuseRequiredNotify");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.GetControllerKey
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// EPhxControllerKeys                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxControllerKeys AWSInteractionWidget::GetControllerKey()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "GetControllerKey");

	Params::WSInteractionWidget_GetControllerKey Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSInteractionWidget.GetTextureFromTexturePack
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UPhxPlatformTexturePack*    TexturePack                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture* AWSInteractionWidget::GetTextureFromTexturePack(const class UPhxPlatformTexturePack* TexturePack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "GetTextureFromTexturePack");

	Params::WSInteractionWidget_GetTextureFromTexturePack Parms{};

	Parms.TexturePack = TexturePack;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSInteractionWidget.HealthFullNotify
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::HealthFullNotify()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "HealthFullNotify");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.HideIcon
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::HideIcon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "HideIcon");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.InitializeWidget
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::InitializeWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "InitializeWidget");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.InputIconActorChildRecreatedNotify
// (Event, Public, BlueprintEvent)

void AWSInteractionWidget::InputIconActorChildRecreatedNotify()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "InputIconActorChildRecreatedNotify");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.InventoryFullNotify
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::InventoryFullNotify()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "InventoryFullNotify");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.NotEnoughCreditsNotify
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::NotEnoughCreditsNotify()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "NotEnoughCreditsNotify");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.NotifyBlockedChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsBlocked                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSInteractionWidget::NotifyBlockedChanged(bool bIsBlocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "NotifyBlockedChanged");

	Params::WSInteractionWidget_NotifyBlockedChanged Parms{};

	Parms.bIsBlocked = bIsBlocked;

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


// Function Phoenix.WSInteractionWidget.NotifyProximityChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// EInteractableProximity                  CurrentProximity                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInteractableProximity                  PreviousProximity                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSInteractionWidget::NotifyProximityChanged(EInteractableProximity CurrentProximity, EInteractableProximity PreviousProximity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "NotifyProximityChanged");

	Params::WSInteractionWidget_NotifyProximityChanged Parms{};

	Parms.CurrentProximity = CurrentProximity;
	Parms.PreviousProximity = PreviousProximity;

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


// Function Phoenix.WSInteractionWidget.NotifyVIDLoaded
// (Event, Protected, BlueprintEvent)

void AWSInteractionWidget::NotifyVIDLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "NotifyVIDLoaded");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.SetButtonPromptSize
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// ESDSSize                                NewSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSInteractionWidget::SetButtonPromptSize(ESDSSize NewSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "SetButtonPromptSize");

	Params::WSInteractionWidget_SetButtonPromptSize Parms{};

	Parms.NewSize = NewSize;

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


// Function Phoenix.WSInteractionWidget.SetProgress
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   ProgressPercentage                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSInteractionWidget::SetProgress(float ProgressPercentage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "SetProgress");

	Params::WSInteractionWidget_SetProgress Parms{};

	Parms.ProgressPercentage = ProgressPercentage;

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


// Function Phoenix.WSInteractionWidget.ShowIcon
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::ShowIcon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "ShowIcon");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInteractionWidget.UpdateWidget
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AWSInteractionWidget::UpdateWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInteractionWidget", "UpdateWidget");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxLevelStreamingTransitionVolume.HandleActorBeginOverlap
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLevelStreamingTransitionVolume::HandleActorBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingTransitionVolume", "HandleActorBeginOverlap");

	Params::PhxLevelStreamingTransitionVolume_HandleActorBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingTransitionVolume.HandleActorEndOverlap
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLevelStreamingTransitionVolume::HandleActorEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingTransitionVolume", "HandleActorEndOverlap");

	Params::PhxLevelStreamingTransitionVolume_HandleActorEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingTransitionVolume.Lock
// (Final, Native, Public, BlueprintCallable)

void APhxLevelStreamingTransitionVolume::Lock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingTransitionVolume", "Lock");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingTransitionVolume.Unlock
// (Final, Native, Public, BlueprintCallable)

void APhxLevelStreamingTransitionVolume::Unlock()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingTransitionVolume", "Unlock");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingTransitionVolume.IsLocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxLevelStreamingTransitionVolume::IsLocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingTransitionVolume", "IsLocked");

	Params::PhxLevelStreamingTransitionVolume_IsLocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSelectable.ConfirmPressed
// (Native, Public, BlueprintCallable)

void AWSSelectable::ConfirmPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "ConfirmPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSelectable.Deselect
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSSelectable::Deselect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "Deselect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSSelectable.NotifyActive
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSelectable::NotifyActive(bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "NotifyActive");

	Params::WSSelectable_NotifyActive Parms{};

	Parms.bActive = bActive;

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


// Function Phoenix.WSSelectable.NotifyLocked
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSSelectable::NotifyLocked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "NotifyLocked");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSSelectable.NotifyUnlocked
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSSelectable::NotifyUnlocked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "NotifyUnlocked");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSSelectable.ReceivedConfirmPressed
// (Event, Public, BlueprintEvent)

void AWSSelectable::ReceivedConfirmPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "ReceivedConfirmPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSSelectable.Select
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSSelectable::Select()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "Select");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSSelectable.SetLocked
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInLocked                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSelectable::SetLocked(bool bInLocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "SetLocked");

	Params::WSSelectable_SetLocked Parms{};

	Parms.bInLocked = bInLocked;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSelectable.SetSelected
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInSelected                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSelectable::SetSelected(bool bInSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "SetSelected");

	Params::WSSelectable_SetSelected Parms{};

	Parms.bInSelected = bInSelected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSelectable.GetAdjacent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AWSSelectable*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSSelectable* AWSSelectable::GetAdjacent(EInputDirection Direction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "GetAdjacent");

	Params::WSSelectable_GetAdjacent Parms{};

	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSelectable.GetIsLocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AWSSelectable::GetIsLocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "GetIsLocked");

	Params::WSSelectable_GetIsLocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSelectable.GetIsSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AWSSelectable::GetIsSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "GetIsSelected");

	Params::WSSelectable_GetIsSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSelectable.GetMenuReaderTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName AWSSelectable::GetMenuReaderTag() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSelectable", "GetMenuReaderTag");

	Params::WSSelectable_GetMenuReaderTag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSButton.NotifyActionDenied
// (Event, Public, BlueprintEvent)

void AWSButton::NotifyActionDenied()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSButton", "NotifyActionDenied");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSButton.SetLabel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AWSButton::SetLabel(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSButton", "SetLabel");

	Params::WSButton_SetLabel Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSkillTreeButton.ApplyVID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UVirtualItemData*           InVID                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSkillTreeButton::ApplyVID(const class UVirtualItemData* InVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTreeButton", "ApplyVID");

	Params::WSSkillTreeButton_ApplyVID Parms{};

	Parms.InVID = InVID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSkillTreeButton.SetItem
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AWSSkillTreeButton::SetItem(const struct FItemData& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTreeButton", "SetItem");

	Params::WSSkillTreeButton_SetItem Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSkillTreeButton.SetOpacity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Opacity                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSkillTreeButton::SetOpacity(float Opacity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTreeButton", "SetOpacity");

	Params::WSSkillTreeButton_SetOpacity Parms{};

	Parms.Opacity = Opacity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSkillTreeButton.GetCachedItemData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData                  ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FItemData AWSSkillTreeButton::GetCachedItemData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTreeButton", "GetCachedItemData");

	Params::WSSkillTreeButton_GetCachedItemData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSkillTreeButton.GetItemRowHandle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FDataTableRowHandle              ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FDataTableRowHandle AWSSkillTreeButton::GetItemRowHandle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSkillTreeButton", "GetItemRowHandle");

	Params::WSSkillTreeButton_GetItemRowHandle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSAmmoButton.SetElementsVisibility
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSAmmoButton::SetElementsVisibility(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSAmmoButton", "SetElementsVisibility");

	Params::WSAmmoButton_SetElementsVisibility Parms{};

	Parms.bVisible = bVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSAmmoButton.GetNumStacks
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AWSAmmoButton::GetNumStacks() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSAmmoButton", "GetNumStacks");

	Params::WSAmmoButton_GetNumStacks Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLightFixture.InitializeLightFixture
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const TArray<class ULightComponent*>&   InLightComponents                                      (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxLightFixture::InitializeLightFixture(const TArray<class ULightComponent*>& InLightComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLightFixture", "InitializeLightFixture");

	Params::PhxLightFixture_InitializeLightFixture Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLightFixture.UpdateFlickerTimelineFunc
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   OutputFlickerPattern                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLightFixture::UpdateFlickerTimelineFunc(float OutputFlickerPattern)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLightFixture", "UpdateFlickerTimelineFunc");

	Params::PhxLightFixture_UpdateFlickerTimelineFunc Parms{};

	Parms.OutputFlickerPattern = OutputFlickerPattern;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSWidgetActor.GetWidgetObject
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UUserWidget*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUserWidget* AWSWidgetActor::GetWidgetObject() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSWidgetActor", "GetWidgetObject");

	Params::WSWidgetActor_GetWidgetObject Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSNotificationActor.PopNotification
// (Final, Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// struct FNotificationData*               OutNotification                                        (Parm, OutParm, NativeAccessSpecifierPublic)
// bool*                                   OutIsValid                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSNotificationActor::PopNotification(struct FNotificationData* OutNotification, bool* OutIsValid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSNotificationActor", "PopNotification");

	Params::WSNotificationActor_PopNotification Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.WSNotificationActor.SetPlaying
// (Event, Public, BlueprintEvent)
// Parameters:
// const class UAudioLogVirtualData*       InAudioVID                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSNotificationActor::SetPlaying(const class UAudioLogVirtualData* InAudioVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSNotificationActor", "SetPlaying");

	Params::WSNotificationActor_SetPlaying Parms{};

	Parms.InAudioVID = InAudioVID;

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


// Function Phoenix.WSNotificationActor.SetQuickSwapUIVisible
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSNotificationActor::SetQuickSwapUIVisible(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSNotificationActor", "SetQuickSwapUIVisible");

	Params::WSNotificationActor_SetQuickSwapUIVisible Parms{};

	Parms.bVisible = bVisible;

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


// Function Phoenix.WSNotificationActor.ShowNotification
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AWSNotificationActor::ShowNotification()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSNotificationActor", "ShowNotification");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSNotificationActor.StopPlaying
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSNotificationActor::StopPlaying()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSNotificationActor", "StopPlaying");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSNotificationActor.GetQuickSwapUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USDSScreenWidget*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSScreenWidget* AWSNotificationActor::GetQuickSwapUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSNotificationActor", "GetQuickSwapUI");

	Params::WSNotificationActor_GetQuickSwapUI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSNotificationActor.HasNotificationQueued
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AWSNotificationActor::HasNotificationQueued() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSNotificationActor", "HasNotificationQueued");

	Params::WSNotificationActor_HasNotificationQueued Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanelUMG.GetUserWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UUserWidget*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUserWidget* AWSPanelUMG::GetUserWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanelUMG", "GetUserWidget");

	Params::WSPanelUMG_GetUserWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSPanelUMG.IsPlayingAnimation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AWSPanelUMG::IsPlayingAnimation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPanelUMG", "IsPlayingAnimation");

	Params::WSPanelUMG_IsPlayingAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDoor.CloseDoor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bQueueIfBusy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::CloseDoor(class APhxCharacter* InteractedBy, bool bQueueIfBusy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "CloseDoor");

	Params::PhxDoor_CloseDoor Parms{};

	Parms.InteractedBy = InteractedBy;
	Parms.bQueueIfBusy = bQueueIfBusy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.DisableScriptedMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxDoorScriptedModeTransitionOut       ScriptedModeTransition                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsDoorOpen                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::DisableScriptedMode(EPhxDoorScriptedModeTransitionOut ScriptedModeTransition, bool bIsDoorOpen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "DisableScriptedMode");

	Params::PhxDoor_DisableScriptedMode Parms{};

	Parms.ScriptedModeTransition = ScriptedModeTransition;
	Parms.bIsDoorOpen = bIsDoorOpen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.DoorStateChanged
// (Event, Public, BlueprintEvent)

void APhxDoor::DoorStateChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "DoorStateChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxDoor.EnableScriptedMode
// (Final, Native, Public, BlueprintCallable)

void APhxDoor::EnableScriptedMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "EnableScriptedMode");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.EndKeycodeScan
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bSuccessful                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::EndKeycodeScan(bool bSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "EndKeycodeScan");

	Params::PhxDoor_EndKeycodeScan Parms{};

	Parms.bSuccessful = bSuccessful;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.HandleRequiredLevelLoaded
// (Final, Native, Protected)

void APhxDoor::HandleRequiredLevelLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "HandleRequiredLevelLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.InitializeAttachedDoorSetup
// (Event, Public, BlueprintEvent)

void APhxDoor::InitializeAttachedDoorSetup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "InitializeAttachedDoorSetup");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxDoor.LockDoor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bLockSideA                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLockSideB                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::LockDoor(bool bLockSideA, bool bLockSideB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "LockDoor");

	Params::PhxDoor_LockDoor Parms{};

	Parms.bLockSideA = bLockSideA;
	Parms.bLockSideB = bLockSideB;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnBioClassLoaded
// (Final, Native, Private)

void APhxDoor::OnBioClassLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnBioClassLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnInteractableProximityChanged
// (Final, Native, Private)
// Parameters:
// EInteractableProximity                  Proximity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInteractableProximity                  PreviousProximity                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::OnInteractableProximityChanged(EInteractableProximity Proximity, EInteractableProximity PreviousProximity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnInteractableProximityChanged");

	Params::PhxDoor_OnInteractableProximityChanged Parms{};

	Parms.Proximity = Proximity;
	Parms.PreviousProximity = PreviousProximity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnProximityBoxBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxDoor::OnProximityBoxBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnProximityBoxBeginOverlap");

	Params::PhxDoor_OnProximityBoxBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnProximityBoxEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::OnProximityBoxEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnProximityBoxEndOverlap");

	Params::PhxDoor_OnProximityBoxEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnPushVolumeBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxDoor::OnPushVolumeBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnPushVolumeBeginOverlap");

	Params::PhxDoor_OnPushVolumeBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnPushVolumeEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::OnPushVolumeEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnPushVolumeEndOverlap");

	Params::PhxDoor_OnPushVolumeEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnScriptedModeDisabled
// (Event, Public, BlueprintEvent)

void APhxDoor::OnScriptedModeDisabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnScriptedModeDisabled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxDoor.OnScriptedModeEnabled
// (Event, Public, BlueprintEvent)

void APhxDoor::OnScriptedModeEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnScriptedModeEnabled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxDoor.OnSideAInteraction
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::OnSideAInteraction(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnSideAInteraction");

	Params::PhxDoor_OnSideAInteraction Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OnSideBInteraction
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::OnSideBInteraction(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OnSideBInteraction");

	Params::PhxDoor_OnSideBInteraction Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.OpenDoor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bQueueIfBusy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::OpenDoor(class APhxCharacter* InteractedBy, bool bQueueIfBusy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "OpenDoor");

	Params::PhxDoor_OpenDoor Parms{};

	Parms.InteractedBy = InteractedBy;
	Parms.bQueueIfBusy = bQueueIfBusy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.RestoreDoor
// (Final, Native, Protected)

void APhxDoor::RestoreDoor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "RestoreDoor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.SetDoorRemainsOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::SetDoorRemainsOpen(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "SetDoorRemainsOpen");

	Params::PhxDoor_SetDoorRemainsOpen Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.SetProximityClose
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::SetProximityClose(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "SetProximityClose");

	Params::PhxDoor_SetProximityClose Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.SetProximityOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::SetProximityOpen(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "SetProximityOpen");

	Params::PhxDoor_SetProximityOpen Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.SetUnlockDoorAfterOpening
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::SetUnlockDoorAfterOpening(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "SetUnlockDoorAfterOpening");

	Params::PhxDoor_SetUnlockDoorAfterOpening Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.StartKeycodeScan
// (Native, Event, Public, BlueprintEvent)

void APhxDoor::StartKeycodeScan()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "StartKeycodeScan");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.UnlockDoor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUnlockSideA                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUnlockSideB                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::UnlockDoor(bool bUnlockSideA, bool bUnlockSideB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "UnlockDoor");

	Params::PhxDoor_UnlockDoor Parms{};

	Parms.bUnlockSideA = bUnlockSideA;
	Parms.bUnlockSideB = bUnlockSideB;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.UpdateNavPowerObstacle
// (Final, Native, Protected)

void APhxDoor::UpdateNavPowerObstacle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "UpdateNavPowerObstacle");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDoor.CanDoorQueueOpenCommand
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxDoor::CanDoorQueueOpenCommand() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "CanDoorQueueOpenCommand");

	Params::PhxDoor_CanDoorQueueOpenCommand Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDoor.GetDoorUIStates
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxDoorUIState*                        SideAState                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxDoorUIState*                        SideBState                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDoor::GetDoorUIStates(const class APhxCharacter* Character, EPhxDoorUIState* SideAState, EPhxDoorUIState* SideBState) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "GetDoorUIStates");

	Params::PhxDoor_GetDoorUIStates Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxDoor.IsCharacterOnSideA
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxDoor::IsCharacterOnSideA(const class APhxCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "IsCharacterOnSideA");

	Params::PhxDoor_IsCharacterOnSideA Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDoor.IsCharacterOnSideB
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxDoor::IsCharacterOnSideB(const class APhxCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDoor", "IsCharacterOnSideB");

	Params::PhxDoor_IsCharacterOnSideB Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehiclePawn.ResetVehicle
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   WCM_Position                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void APhxVehiclePawn::ResetVehicle(const struct FVector& WCM_Position, const struct FRotator& Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehiclePawn", "ResetVehicle");

	Params::PhxVehiclePawn_ResetVehicle Parms{};

	Parms.WCM_Position = std::move(WCM_Position);
	Parms.Rotation = std::move(Rotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxVehiclePawn.GetShouldVehicleResetToCheckpoint
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxVehiclePawn::GetShouldVehicleResetToCheckpoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehiclePawn", "GetShouldVehicleResetToCheckpoint");

	Params::PhxVehiclePawn_GetShouldVehicleResetToCheckpoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWeakSpotComponent.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeakSpotComponent::SetEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeakSpotComponent", "SetEnabled");

	Params::PhxWeakSpotComponent_SetEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeakSpotComponent.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxWeakSpotComponent::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeakSpotComponent", "IsEnabled");

	Params::PhxWeakSpotComponent_IsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCorpse.GetMeshBoneData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMeshBoneData*                   BoneData                                               (Parm, OutParm, ContainsInstancedReference, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCorpse::GetMeshBoneData(class FName BoneName, struct FMeshBoneData* BoneData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCorpse", "GetMeshBoneData");

	Params::PhxCorpse_GetMeshBoneData Parms{};

	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHarvestCorpse.OnActorRestored
// (Final, Native, Protected)

void APhxHarvestCorpse::OnActorRestored()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHarvestCorpse", "OnActorRestored");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHarvestCorpse.OnInteract
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxHarvestCorpse::OnInteract(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHarvestCorpse", "OnInteract");

	Params::PhxHarvestCorpse_OnInteract Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPPEHitResponseComponent.OnPPEHitBPE
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FPPEHitResponseData&       ResponseData                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxPPEHitResponseComponent::OnPPEHitBPE(const struct FPPEHitResponseData& ResponseData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPPEHitResponseComponent", "OnPPEHitBPE");

	Params::PhxPPEHitResponseComponent_OnPPEHitBPE Parms{};

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

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


// Function Phoenix.PhxEnemyPPEHitResponseComponent.OnEnterPPEState
// (Event, Public, BlueprintEvent)

void UPhxEnemyPPEHitResponseComponent::OnEnterPPEState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxEnemyPPEHitResponseComponent", "OnEnterPPEState");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxEnemyPPEHitResponseComponent.OnExitPPEState
// (Event, Public, BlueprintEvent)

void UPhxEnemyPPEHitResponseComponent::OnExitPPEState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxEnemyPPEHitResponseComponent", "OnExitPPEState");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxWaitForLevelStreamingComplete.CreateWaitForLevelStreamingComplete
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<TSoftObjectPtr<class UWorld>>&InLevelsToCheck                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)
// bool                                    CheckIfLoaded_0                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimerInterval_0                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxWaitForLevelStreamingComplete*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxWaitForLevelStreamingComplete* UPhxWaitForLevelStreamingComplete::CreateWaitForLevelStreamingComplete(class UObject* WorldContextObject, const TArray<TSoftObjectPtr<class UWorld>>& InLevelsToCheck, bool CheckIfLoaded_0, float TimerInterval_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxWaitForLevelStreamingComplete", "CreateWaitForLevelStreamingComplete");

	Params::PhxWaitForLevelStreamingComplete_CreateWaitForLevelStreamingComplete Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InLevelsToCheck = std::move(InLevelsToCheck);
	Parms.CheckIfLoaded_0 = CheckIfLoaded_0;
	Parms.TimerInterval_0 = TimerInterval_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnEnterMontageBlendOut
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnEnterMontageBlendOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnEnterMontageBlendOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnEnterMontageCancelled
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnEnterMontageCancelled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnEnterMontageCancelled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnEnterMontageComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnEnterMontageComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnEnterMontageComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnEnterMontageInterrupted
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnEnterMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnEnterMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnExitMontageBlendOut
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnExitMontageBlendOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnExitMontageBlendOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnExitMontageCancelled
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnExitMontageCancelled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnExitMontageCancelled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnExitMontageComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnExitMontageComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnExitMontageComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnExitMontageInterrupted
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnExitMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnExitMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnMoveAlongSplineCompleted
// (Final, Native, Private)
// Parameters:
// ESplineEnd                              InSplineExitEnd                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Traverse_Spline::OnMoveAlongSplineCompleted(ESplineEnd InSplineExitEnd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnMoveAlongSplineCompleted");

	Params::PhxGameplayAbility_Traverse_Spline_OnMoveAlongSplineCompleted Parms{};

	Parms.InSplineExitEnd = InSplineExitEnd;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Spline.OnMoveAlongSplineInterrupted
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Spline::OnMoveAlongSplineInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Spline", "OnMoveAlongSplineInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSAudioLogButton.SetOrderNumber
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSAudioLogButton::SetOrderNumber(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSAudioLogButton", "SetOrderNumber");

	Params::SDSAudioLogButton_SetOrderNumber Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSAudioLogButton.SetPlaying
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bPlaying                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSAudioLogButton::SetPlaying(bool bPlaying)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSAudioLogButton", "SetPlaying");

	Params::SDSAudioLogButton_SetPlaying Parms{};

	Parms.bPlaying = bPlaying;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSAudioLogButton.SetTitle
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSAudioLogButton::SetTitle(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSAudioLogButton", "SetTitle");

	Params::SDSAudioLogButton_SetTitle Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSAudioLogButton.IsPlaying
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USDSAudioLogButton::IsPlaying() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSAudioLogButton", "IsPlaying");

	Params::SDSAudioLogButton_IsPlaying Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSKitBash.HandleInteraction
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASDSKitBash::HandleInteraction(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSKitBash", "HandleInteraction");

	Params::SDSKitBash_HandleInteraction Parms{};

	Parms.InteractedBy = InteractedBy;

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


// Function Phoenix.SDSKitBash.GetChildActor
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* ASDSKitBash::GetChildActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSKitBash", "GetChildActor");

	Params::SDSKitBash_GetChildActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSCancelHandler.CancelPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSCancelHandler::CancelPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSCancelHandler", "CancelPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterWidget.AddDynamicSpace
// (Event, Public, BlueprintEvent)
// Parameters:
// class APhxLevelPacingMeterSpace*        NewLevelSpace                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterWidget::AddDynamicSpace(class APhxLevelPacingMeterSpace* NewLevelSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "AddDynamicSpace");

	Params::PhxLevelPacingMeterWidget_AddDynamicSpace Parms{};

	Parms.NewLevelSpace = NewLevelSpace;

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


// Function Phoenix.PhxLevelPacingMeterWidget.ClearDynamicSpaces
// (Event, Public, BlueprintEvent)

void UPhxLevelPacingMeterWidget::ClearDynamicSpaces()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "ClearDynamicSpaces");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxLevelPacingMeterWidget.HideDynamicMeter
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UPhxLevelPacingMeterWidget::HideDynamicMeter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "HideDynamicMeter");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxLevelPacingMeterWidget.HideStaticMeter
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UPhxLevelPacingMeterWidget::HideStaticMeter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "HideStaticMeter");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxLevelPacingMeterWidget.ResetCurrentSpace
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UPhxLevelPacingMeterWidget::ResetCurrentSpace()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "ResetCurrentSpace");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxLevelPacingMeterWidget.SetupStaticMeter
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<class APhxLevelPacingMeterSpace*>&NewLevelPacingSpaces                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterWidget::SetupStaticMeter(const TArray<class APhxLevelPacingMeterSpace*>& NewLevelPacingSpaces)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "SetupStaticMeter");

	Params::PhxLevelPacingMeterWidget_SetupStaticMeter Parms{};

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

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


// Function Phoenix.PhxLevelPacingMeterWidget.ShowDynamicMeter
// (Event, Public, BlueprintEvent)

void UPhxLevelPacingMeterWidget::ShowDynamicMeter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "ShowDynamicMeter");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxLevelPacingMeterWidget.ShowStaticMeter
// (Event, Public, BlueprintEvent)

void UPhxLevelPacingMeterWidget::ShowStaticMeter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterWidget", "ShowStaticMeter");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxBTTask_PlayPostSpawnAnimation.OnMontageBlendingOut
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxBTTask_PlayPostSpawnAnimation::OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxBTTask_PlayPostSpawnAnimation", "OnMontageBlendingOut");

	Params::PhxBTTask_PlayPostSpawnAnimation_OnMontageBlendingOut Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTreadmill.ActivateTreadmill
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ForUser                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxTreadmill::ActivateTreadmill(bool bActive, class AActor* ForUser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTreadmill", "ActivateTreadmill");

	Params::PhxTreadmill_ActivateTreadmill Parms{};

	Parms.bActive = bActive;
	Parms.ForUser = ForUser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTreadmill.OnPostSpawnTile
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           TileActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxTreadmill::OnPostSpawnTile(class AActor* TileActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTreadmill", "OnPostSpawnTile");

	Params::PhxTreadmill_OnPostSpawnTile Parms{};

	Parms.TileActor = TileActor;

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


// Function Phoenix.PhxTreadmill.OnPreUnspawnTile
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           TileActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxTreadmill::OnPreUnspawnTile(class AActor* TileActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTreadmill", "OnPreUnspawnTile");

	Params::PhxTreadmill_OnPreUnspawnTile Parms{};

	Parms.TileActor = TileActor;

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


// Function Phoenix.PhxTreadmill.OnTreadmillActivated
// (Event, Public, BlueprintEvent)

void APhxTreadmill::OnTreadmillActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTreadmill", "OnTreadmillActivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxTreadmill.OnTreadmillDeactivated
// (Event, Public, BlueprintEvent)

void APhxTreadmill::OnTreadmillDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTreadmill", "OnTreadmillDeactivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxTreadmill.OnTreadmillMoved
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   Translation                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxTreadmill::OnTreadmillMoved(const struct FVector& Translation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTreadmill", "OnTreadmillMoved");

	Params::PhxTreadmill_OnTreadmillMoved Parms{};

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

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


// Function Phoenix.PhxTutorialSystem.HandleInputChange
// (Final, Native, Private)

void UPhxTutorialSystem::HandleInputChange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTutorialSystem", "HandleInputChange");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTutorialSystem.RemoveTutorialHint
// (Final, Native, Public, BlueprintCallable)

void UPhxTutorialSystem::RemoveTutorialHint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTutorialSystem", "RemoveTutorialHint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTutorialSystem.RemoveTutorialHintImmediate
// (Final, Native, Public, BlueprintCallable)

void UPhxTutorialSystem::RemoveTutorialHintImmediate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTutorialSystem", "RemoveTutorialHintImmediate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTutorialSystem.RequestTutorialHint
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FTutorialHintRequest&      InRequest                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnSuccess                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxTutorialSystem::RequestTutorialHint(const struct FTutorialHintRequest& InRequest, const TDelegate<void()>& OnSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTutorialSystem", "RequestTutorialHint");

	Params::PhxTutorialSystem_RequestTutorialHint Parms{};

	Parms.InRequest = std::move(InRequest);
	Parms.OnSuccess = OnSuccess;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.OnCharacterRagdoll
// (Final, Native, Public)
// Parameters:
// class UPhxSkeletalMeshComponent*        MeshComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::OnCharacterRagdoll(class UPhxSkeletalMeshComponent* MeshComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "OnCharacterRagdoll");

	Params::PhxDialogueSystem_OnCharacterRagdoll Parms{};

	Parms.MeshComp = MeshComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.PauseAudioLog
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InAudioLog                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::PauseAudioLog(class UDialogue* InAudioLog)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "PauseAudioLog");

	Params::PhxDialogueSystem_PauseAudioLog Parms{};

	Parms.InAudioLog = InAudioLog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.PlayAudioLog
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InAudioLog                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Speaker                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::PlayAudioLog(class UDialogue* InAudioLog, class AActor* Speaker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "PlayAudioLog");

	Params::PhxDialogueSystem_PlayAudioLog Parms{};

	Parms.InAudioLog = InAudioLog;
	Parms.Speaker = Speaker;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.PlayDialogue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InDialogue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           SpeakingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::PlayDialogue(class UDialogue* InDialogue, class AActor* SpeakingActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "PlayDialogue");

	Params::PhxDialogueSystem_PlayDialogue Parms{};

	Parms.InDialogue = InDialogue;
	Parms.SpeakingActor = SpeakingActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.SetDialogueDebug
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::SetDialogueDebug(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "SetDialogueDebug");

	Params::PhxDialogueSystem_SetDialogueDebug Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.StopAllDialogueOnActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::StopAllDialogueOnActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "StopAllDialogueOnActor");

	Params::PhxDialogueSystem_StopAllDialogueOnActor Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.StopAudioLog
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InAudioLog                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::StopAudioLog(class UDialogue* InAudioLog)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "StopAudioLog");

	Params::PhxDialogueSystem_StopAudioLog Parms{};

	Parms.InAudioLog = InAudioLog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.StopDialogue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InDialogue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::StopDialogue(class UDialogue* InDialogue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "StopDialogue");

	Params::PhxDialogueSystem_StopDialogue Parms{};

	Parms.InDialogue = InDialogue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueSystem.TestCombatStateChange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         PreviousGameState                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         NewGameState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueSystem::TestCombatStateChange(class UPhxAIGameStateManager* GameStateManager, EPhxAIGameState PreviousGameState, EPhxAIGameState NewGameState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueSystem", "TestCombatStateChange");

	Params::PhxDialogueSystem_TestCombatStateChange Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.PreviousGameState = PreviousGameState;
	Parms.NewGameState = NewGameState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxButton.MouseClickInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxInputKeys                           InputAction                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxButton::MouseClickInput(EPhxInputKeys InputAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxButton", "MouseClickInput");

	Params::PhxButton_MouseClickInput Parms{};

	Parms.InputAction = InputAction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxButton.MousePressInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxInputKeys                           InputAction                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsPressed                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxButton::MousePressInput(EPhxInputKeys InputAction, bool bIsPressed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxButton", "MousePressInput");

	Params::PhxButton_MousePressInput Parms{};

	Parms.InputAction = InputAction;
	Parms.bIsPressed = bIsPressed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxButton.SetLabel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxButton::SetLabel(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxButton", "SetLabel");

	Params::PhxButton_SetLabel Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxButtonWithInfo.SetInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxButtonWithInfo::SetInfo(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxButtonWithInfo", "SetInfo");

	Params::PhxButtonWithInfo_SetInfo Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PlayerInputFSM.HandleOnHealthChanged
// (Final, Native, Protected)
// Parameters:
// class UPhxHealthComponent*              CallingHealthComp                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerInputFSM::HandleOnHealthChanged(class UPhxHealthComponent* CallingHealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInputFSM", "HandleOnHealthChanged");

	Params::PlayerInputFSM_HandleOnHealthChanged Parms{};

	Parms.CallingHealthComp = CallingHealthComp;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PlayerInputFSM.ToggleMenu
// (Final, Native, Protected)

void UPlayerInputFSM::ToggleMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInputFSM", "ToggleMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.ActivateFunicular
// (Final, Native, Public, BlueprintCallable)

void APhxFunicularSequenceController::ActivateFunicular()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "ActivateFunicular");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.OnActorBoardedStartPlatform
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxFunicularSequenceController::OnActorBoardedStartPlatform(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "OnActorBoardedStartPlatform");

	Params::PhxFunicularSequenceController_OnActorBoardedStartPlatform Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.OnPlayerFell
// (Event, Public, BlueprintEvent)

void APhxFunicularSequenceController::OnPlayerFell()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "OnPlayerFell");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxFunicularSequenceController.SetSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewSpeed                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxFunicularSequenceController::SetSpeed(float NewSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "SetSpeed");

	Params::PhxFunicularSequenceController_SetSpeed Parms{};

	Parms.NewSpeed = NewSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.SetTime
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewTime                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxFunicularSequenceController::SetTime(float NewTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "SetTime");

	Params::PhxFunicularSequenceController_SetTime Parms{};

	Parms.NewTime = NewTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.StartTimer
// (Final, Native, Public, BlueprintCallable)

void APhxFunicularSequenceController::StartTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "StartTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.StopTimer
// (Final, Native, Public, BlueprintCallable)

void APhxFunicularSequenceController::StopTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "StopTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.TeleportToEnd
// (Final, Native, Public, BlueprintCallable)

void APhxFunicularSequenceController::TeleportToEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "TeleportToEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.TeleportToLoop
// (Final, Native, Public, BlueprintCallable)

void APhxFunicularSequenceController::TeleportToLoop()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "TeleportToLoop");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFunicularSequenceController.GetSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxFunicularSequenceController::GetSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "GetSpeed");

	Params::PhxFunicularSequenceController_GetSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxFunicularSequenceController.GetTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxFunicularSequenceController::GetTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFunicularSequenceController", "GetTime");

	Params::PhxFunicularSequenceController_GetTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility_ButtonInteraction.OnDelayTimePassed
// (Final, Native, Protected)

void UPhxGameplayAbility_ButtonInteraction::OnDelayTimePassed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_ButtonInteraction", "OnDelayTimePassed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.AllowToFall
// (Final, Native, Protected, BlueprintCallable)

void APPEPuzzleBlock::AllowToFall()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "AllowToFall");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.DropBlock
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   nShotPower                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEPuzzleBlock::DropBlock(int32 nShotPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "DropBlock");

	Params::PPEPuzzleBlock_DropBlock Parms{};

	Parms.nShotPower = nShotPower;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.GetAllBlocksAtBottom
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class APPEPuzzleBlock*                  BlockToCheck                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class APPEPuzzleBlock*>*         OutBottomBlockList                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void APPEPuzzleBlock::GetAllBlocksAtBottom(class APPEPuzzleBlock* BlockToCheck, TArray<class APPEPuzzleBlock*>* OutBottomBlockList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "GetAllBlocksAtBottom");

	Params::PPEPuzzleBlock_GetAllBlocksAtBottom Parms{};

	Parms.BlockToCheck = BlockToCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PPEPuzzleBlock.GetAllBlocksOnTop
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class APPEPuzzleBlock*                  BlockToCheck                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class APPEPuzzleBlock*>*         OutTopBlockList                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void APPEPuzzleBlock::GetAllBlocksOnTop(class APPEPuzzleBlock* BlockToCheck, TArray<class APPEPuzzleBlock*>* OutTopBlockList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "GetAllBlocksOnTop");

	Params::PPEPuzzleBlock_GetAllBlocksOnTop Parms{};

	Parms.BlockToCheck = BlockToCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PPEPuzzleBlock.GetPuzzleBlockMesh
// (Final, Native, Protected)
// Parameters:
// class UStaticMeshComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UStaticMeshComponent* APPEPuzzleBlock::GetPuzzleBlockMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "GetPuzzleBlockMesh");

	Params::PPEPuzzleBlock_GetPuzzleBlockMesh Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PPEPuzzleBlock.LiftBlock
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   nShotPower                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEPuzzleBlock::LiftBlock(int32 nShotPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "LiftBlock");

	Params::PPEPuzzleBlock_LiftBlock Parms{};

	Parms.nShotPower = nShotPower;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.OnBoxHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "OnBoxHit");

	Params::PPEPuzzleBlock_OnBoxHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.OnTopBlockBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APPEPuzzleBlock::OnTopBlockBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "OnTopBlockBeginOverlap");

	Params::PPEPuzzleBlock_OnTopBlockBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.OnTopBlockEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEPuzzleBlock::OnTopBlockEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "OnTopBlockEndOverlap");

	Params::PPEPuzzleBlock_OnTopBlockEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.OnWeightLevelChanged
// (Event, Public, BlueprintEvent)

void APPEPuzzleBlock::OnWeightLevelChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "OnWeightLevelChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PPEPuzzleBlock.PushPullBlock
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   ShotDirection                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ShotPower                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEPuzzleBlock::PushPullBlock(const struct FVector& ShotDirection, int32 ShotPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "PushPullBlock");

	Params::PPEPuzzleBlock_PushPullBlock Parms{};

	Parms.ShotDirection = std::move(ShotDirection);
	Parms.ShotPower = ShotPower;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEPuzzleBlock.GetWeightLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EWeightLevel                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EWeightLevel APPEPuzzleBlock::GetWeightLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "GetWeightLevel");

	Params::PPEPuzzleBlock_GetWeightLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PPEPuzzleBlock.GetWeightValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APPEPuzzleBlock::GetWeightValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEPuzzleBlock", "GetWeightValue");

	Params::PPEPuzzleBlock_GetWeightValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHasAllOfEntitlements.HasAllOfEntitlement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const TArray<EPhxEntitlement>&          InEntitlements                                         (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UPhxHasAllOfEntitlements*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxHasAllOfEntitlements* UPhxHasAllOfEntitlements::HasAllOfEntitlement(const TArray<EPhxEntitlement>& InEntitlements)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxHasAllOfEntitlements", "HasAllOfEntitlement");

	Params::PhxHasAllOfEntitlements_HasAllOfEntitlement Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHasAllOfEntitlements.HandleFetchEntitlements
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxEntitlementOwnership&  Ownership                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxHasAllOfEntitlements::HandleFetchEntitlements(const struct FPhxEntitlementOwnership& Ownership)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasAllOfEntitlements", "HandleFetchEntitlements");

	Params::PhxHasAllOfEntitlements_HandleFetchEntitlements Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHasAllOfEntitlements.HandleFetchOnlineAccount
// (Final, Native, Protected)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USDSOnlineAccount*          OnlineAccount                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHasAllOfEntitlements::HandleFetchOnlineAccount(bool bSuccess, const class USDSOnlineAccount* OnlineAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasAllOfEntitlements", "HandleFetchOnlineAccount");

	Params::PhxHasAllOfEntitlements_HandleFetchOnlineAccount Parms{};

	Parms.bSuccess = bSuccess;
	Parms.OnlineAccount = OnlineAccount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWorldMarkerSystem.RemoveMarker
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxWorldMarker*                  MarkerToRemove                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWorldMarkerSystem::RemoveMarker(class APhxWorldMarker* MarkerToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldMarkerSystem", "RemoveMarker");

	Params::PhxWorldMarkerSystem_RemoveMarker Parms{};

	Parms.MarkerToRemove = MarkerToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWorldMarkerSystem.SpawnMarkerAtLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// TSubclassOf<class APhxWorldMarker>      MarkerClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  TargetRotation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class APhxWorldMarker*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxWorldMarker* UPhxWorldMarkerSystem::SpawnMarkerAtLocation(TSubclassOf<class APhxWorldMarker> MarkerClass, const struct FVector& TargetLocation, const struct FRotator& TargetRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldMarkerSystem", "SpawnMarkerAtLocation");

	Params::PhxWorldMarkerSystem_SpawnMarkerAtLocation Parms{};

	Parms.MarkerClass = MarkerClass;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.TargetRotation = std::move(TargetRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldMarkerSystem.SpawnMarkerOnActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class APhxWorldMarker>      MarkerClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     TargetActor                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Height                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxWorldMarker*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxWorldMarker* UPhxWorldMarkerSystem::SpawnMarkerOnActor(TSubclassOf<class APhxWorldMarker> MarkerClass, const class AActor* TargetActor, float Height)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldMarkerSystem", "SpawnMarkerOnActor");

	Params::PhxWorldMarkerSystem_SpawnMarkerOnActor Parms{};

	Parms.MarkerClass = MarkerClass;
	Parms.TargetActor = TargetActor;
	Parms.Height = Height;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraModifierGroup.RemoveModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxCameraModifier*               Modifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Immediately                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCameraModifierGroup::RemoveModifier(class UPhxCameraModifier* Modifier, bool Immediately)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraModifierGroup", "RemoveModifier");

	Params::PhxCameraModifierGroup_RemoveModifier Parms{};

	Parms.Modifier = Modifier;
	Parms.Immediately = Immediately;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHitmaskSpreadComponent.RenderHit
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHitmaskSpreadComponent::RenderHit(const struct FVector& Position, class FName BoneName, float Damage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHitmaskSpreadComponent", "RenderHit");

	Params::PhxHitmaskSpreadComponent_RenderHit Parms{};

	Parms.Position = std::move(Position);
	Parms.BoneName = BoneName;
	Parms.Damage = Damage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInputActionMappingData.GetInputKeyList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FKey>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKey> UPhxInputActionMappingData::GetInputKeyList(EPhxInputType InType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputActionMappingData", "GetInputKeyList");

	Params::PhxInputActionMappingData_GetInputKeyList Parms{};

	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputActionMappingData.GetInputKeyForUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UPhxInputActionMappingData::GetInputKeyForUI(EPhxInputType InType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputActionMappingData", "GetInputKeyForUI");

	Params::PhxInputActionMappingData_GetInputKeyForUI Parms{};

	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputActionMappingData.IsInputType
// (Final, Native, Public, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxInputActionMappingData::IsInputType(const struct FKey& Key, EPhxInputType InType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputActionMappingData", "IsInputType");

	Params::PhxInputActionMappingData_IsInputType Parms{};

	Parms.Key = std::move(Key);
	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraRig.LimitControlRotation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FRotator&                  Rotator                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  Against                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  Minimum                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  Maximum                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator APhxCameraRig::LimitControlRotation(const struct FRotator& Rotator, const struct FRotator& Against, const struct FRotator& Minimum, const struct FRotator& Maximum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCameraRig", "LimitControlRotation");

	Params::PhxCameraRig_LimitControlRotation Parms{};

	Parms.Rotator = std::move(Rotator);
	Parms.Against = std::move(Against);
	Parms.Minimum = std::move(Minimum);
	Parms.Maximum = std::move(Maximum);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraRig.ActivateCameraGraphEntry
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FCameraGraphEntrySelector& TargetEntry                                            (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Activate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCameraRig::ActivateCameraGraphEntry(const struct FCameraGraphEntrySelector& TargetEntry, bool Activate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraRig", "ActivateCameraGraphEntry");

	Params::PhxCameraRig_ActivateCameraGraphEntry Parms{};

	Parms.TargetEntry = std::move(TargetEntry);
	Parms.Activate = Activate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraRig.AddModifier
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSubclassOf<class UPhxCameraModifier>&ModfierClass                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCameraRig::AddModifier(const TSubclassOf<class UPhxCameraModifier>& ModfierClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraRig", "AddModifier");

	Params::PhxCameraRig_AddModifier Parms{};

	Parms.ModfierClass = ModfierClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraRig.GetCameraActor
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ACameraActor*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ACameraActor* APhxCameraRig::GetCameraActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraRig", "GetCameraActor");

	Params::PhxCameraRig_GetCameraActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraRig.GetCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCharacter* APhxCameraRig::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraRig", "GetCharacter");

	Params::PhxCameraRig_GetCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraRig.GetMover
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxCameraMover*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCameraMover* APhxCameraRig::GetMover() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraRig", "GetMover");

	Params::PhxCameraRig_GetMover Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraRig.GetPhotoModeCameraActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ACameraActor*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ACameraActor* APhxCameraRig::GetPhotoModeCameraActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraRig", "GetPhotoModeCameraActor");

	Params::PhxCameraRig_GetPhotoModeCameraActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCameraRig.IsPhotoModeMovementLocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxCameraRig::IsPhotoModeMovementLocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraRig", "IsPhotoModeMovementLocked");

	Params::PhxCameraRig_IsPhotoModeMovementLocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWoundComponent.InitWoundManager
// (Final, Native, Public, BlueprintCallable)

void UPhxWoundComponent::InitWoundManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWoundComponent", "InitWoundManager");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCameraVolumeHandler.GetModifierProximity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UPhxCameraModifier>   ModifierClass                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCameraVolumeHandler::GetModifierProximity(TSubclassOf<class UPhxCameraModifier> ModifierClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCameraVolumeHandler", "GetModifierProximity");

	Params::PhxCameraVolumeHandler_GetModifierProximity Parms{};

	Parms.ModifierClass = ModifierClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCapsuleComponent.ClearOverrides
// (Final, Native, Public, BlueprintCallable)

void UPhxCapsuleComponent::ClearOverrides()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCapsuleComponent", "ClearOverrides");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCapsuleComponent.OverrideSize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewRadius                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NewHalfHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InterpolateTime                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCapsuleComponent::OverrideSize(float NewRadius, float NewHalfHeight, float InterpolateTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCapsuleComponent", "OverrideSize");

	Params::PhxCapsuleComponent_OverrideSize Parms{};

	Parms.NewRadius = NewRadius;
	Parms.NewHalfHeight = NewHalfHeight;
	Parms.InterpolateTime = InterpolateTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCapsuleComponent.RefreshCapsuleSize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCapsuleComponent::RefreshCapsuleSize(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCapsuleComponent", "RefreshCapsuleSize");

	Params::PhxCapsuleComponent_RefreshCapsuleSize Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCapsuleComponent.GetCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxCharacter*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxCharacter* UPhxCapsuleComponent::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCapsuleComponent", "GetCharacter");

	Params::PhxCapsuleComponent_GetCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCapsuleComponent.GetDesiredSize
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  Radius                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  HalfHeight                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCapsuleComponent::GetDesiredSize(float* Radius, float* HalfHeight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCapsuleComponent", "GetDesiredSize");

	Params::PhxCapsuleComponent_GetDesiredSize Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxCarouselComponent.GetRotationStep
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCarouselComponent::GetRotationStep() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCarouselComponent", "GetRotationStep");

	Params::PhxCarouselComponent_GetRotationStep Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCatwalkClimbActor.OnCollapseSequenceFinished
// (Final, Native, Protected)

void APhxCatwalkClimbActor::OnCollapseSequenceFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCatwalkClimbActor", "OnCollapseSequenceFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCatwalkClimbActor.OnEnterSequenceFinished
// (Final, Native, Protected)

void APhxCatwalkClimbActor::OnEnterSequenceFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCatwalkClimbActor", "OnEnterSequenceFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCatwalkClimbActor.OnEntryInteractionExecuted
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCatwalkClimbActor::OnEntryInteractionExecuted(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCatwalkClimbActor", "OnEntryInteractionExecuted");

	Params::PhxCatwalkClimbActor_OnEntryInteractionExecuted Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCatwalkClimbActor.OnEntryInteractionInitialized
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxCatwalkClimbActor::OnEntryInteractionInitialized(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCatwalkClimbActor", "OnEntryInteractionInitialized");

	Params::PhxCatwalkClimbActor_OnEntryInteractionInitialized Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCatwalkClimbActor.OnLookBackSequenceFinished
// (Final, Native, Protected)

void APhxCatwalkClimbActor::OnLookBackSequenceFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCatwalkClimbActor", "OnLookBackSequenceFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCatwalkClimbActor.OnPlayerJumpedOnCatwalk
// (Final, Native, Public, BlueprintCallable)

void APhxCatwalkClimbActor::OnPlayerJumpedOnCatwalk()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCatwalkClimbActor", "OnPlayerJumpedOnCatwalk");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTraversalSplinePoint_Animation.UpdateEditorPreview
// (Native, Protected)

void APhxTraversalSplinePoint_Animation::UpdateEditorPreview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalSplinePoint_Animation", "UpdateEditorPreview");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterGoreComponent.RegisterBodyPartMutationMap
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxBodyPartType                        BodyPartType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPhxMutatedBodyPart&       BodyPartMutationMeshes                                 (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxCharacterGoreComponent::RegisterBodyPartMutationMap(EPhxBodyPartType BodyPartType, const struct FPhxMutatedBodyPart& BodyPartMutationMeshes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "RegisterBodyPartMutationMap");

	Params::PhxCharacterGoreComponent_RegisterBodyPartMutationMap Parms{};

	Parms.BodyPartType = BodyPartType;
	Parms.BodyPartMutationMeshes = std::move(BodyPartMutationMeshes);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterGoreComponent.RegisterExplicitGoreCapComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxBodyPartType                        BodyPartType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           SkeletalMeshComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterGoreComponent::RegisterExplicitGoreCapComponent(EPhxBodyPartType BodyPartType, class USkeletalMeshComponent* SkeletalMeshComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "RegisterExplicitGoreCapComponent");

	Params::PhxCharacterGoreComponent_RegisterExplicitGoreCapComponent Parms{};

	Parms.BodyPartType = BodyPartType;
	Parms.SkeletalMeshComponent = SkeletalMeshComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterGoreComponent.RegisterGoreSkeletalMeshComponents
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPhxGoreSkeletalMeshesInfo&GoreMeshesInfo                                         (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxCharacterGoreComponent::RegisterGoreSkeletalMeshComponents(const struct FPhxGoreSkeletalMeshesInfo& GoreMeshesInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "RegisterGoreSkeletalMeshComponents");

	Params::PhxCharacterGoreComponent_RegisterGoreSkeletalMeshComponents Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterGoreComponent.RegisterPristineSkeletalMeshComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           PristineMesh                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterGoreComponent::RegisterPristineSkeletalMeshComponent(class USkeletalMeshComponent* PristineMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "RegisterPristineSkeletalMeshComponent");

	Params::PhxCharacterGoreComponent_RegisterPristineSkeletalMeshComponent Parms{};

	Parms.PristineMesh = PristineMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterGoreComponent.RegisterSkeletalMeshCompnent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxBodyPartType                        BodyPartType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           SkeletalMeshComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterGoreComponent::RegisterSkeletalMeshCompnent(EPhxBodyPartType BodyPartType, class USkeletalMeshComponent* SkeletalMeshComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "RegisterSkeletalMeshCompnent");

	Params::PhxCharacterGoreComponent_RegisterSkeletalMeshCompnent Parms{};

	Parms.BodyPartType = BodyPartType;
	Parms.SkeletalMeshComponent = SkeletalMeshComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterGoreComponent.TEST_GetBodyPartHealth
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCharacterGoreComponent::TEST_GetBodyPartHealth(class FName BoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "TEST_GetBodyPartHealth");

	Params::PhxCharacterGoreComponent_TEST_GetBodyPartHealth Parms{};

	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterGoreComponent.TEST_SetBodyPartHealth
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterGoreComponent::TEST_SetBodyPartHealth(class FName BoneName, float Health)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "TEST_SetBodyPartHealth");

	Params::PhxCharacterGoreComponent_TEST_SetBodyPartHealth Parms{};

	Parms.BoneName = BoneName;
	Parms.Health = Health;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterGoreComponent.TryAutoDismemberBodyPart
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EUntaggedWoundType                      GoreType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ImpactDirection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class ULimbDetatchmentBehaviorBase>PreferredDetatchmentBehavior                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterGoreComponent::TryAutoDismemberBodyPart(class FName BoneName, EUntaggedWoundType GoreType, const struct FVector& ImpactDirection, TSubclassOf<class ULimbDetatchmentBehaviorBase> PreferredDetatchmentBehavior)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "TryAutoDismemberBodyPart");

	Params::PhxCharacterGoreComponent_TryAutoDismemberBodyPart Parms{};

	Parms.BoneName = BoneName;
	Parms.GoreType = GoreType;
	Parms.ImpactDirection = std::move(ImpactDirection);
	Parms.PreferredDetatchmentBehavior = PreferredDetatchmentBehavior;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterGoreComponent.TrySwapPristineMeshes
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterGoreComponent::TrySwapPristineMeshes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "TrySwapPristineMeshes");

	Params::PhxCharacterGoreComponent_TrySwapPristineMeshes Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterGoreComponent.GetBodyPartHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxBodyPartType                        BodyPart                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCharacterGoreComponent::GetBodyPartHealth(EPhxBodyPartType BodyPart) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "GetBodyPartHealth");

	Params::PhxCharacterGoreComponent_GetBodyPartHealth Parms{};

	Parms.BodyPart = BodyPart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterGoreComponent.GetBodyPartHealthPercent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxBodyPartType                        BodyPart                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCharacterGoreComponent::GetBodyPartHealthPercent(EPhxBodyPartType BodyPart) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "GetBodyPartHealthPercent");

	Params::PhxCharacterGoreComponent_GetBodyPartHealthPercent Parms{};

	Parms.BodyPart = BodyPart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterGoreComponent.GetBodyPartMaxHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxBodyPartType                        BodyPart                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCharacterGoreComponent::GetBodyPartMaxHealth(EPhxBodyPartType BodyPart) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterGoreComponent", "GetBodyPartMaxHealth");

	Params::PhxCharacterGoreComponent_GetBodyPartMaxHealth Parms{};

	Parms.BodyPart = BodyPart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHealthComponent.HandleTakeAnyDamage
// (Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHealthComponent::HandleTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHealthComponent", "HandleTakeAnyDamage");

	Params::PhxHealthComponent_HandleTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHealthComponent.Heal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   HealAmount                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                HealType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           HealCauser                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHealthComponent::Heal(float HealAmount, const class UDamageType* HealType, class AController* InstigatedBy, class AActor* HealCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHealthComponent", "Heal");

	Params::PhxHealthComponent_Heal Parms{};

	Parms.HealAmount = HealAmount;
	Parms.HealType = HealType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.HealCauser = HealCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHealthComponent.Kill
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UDamageType>          DamageType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHealthComponent::Kill(class AActor* DamageCauser, TSubclassOf<class UDamageType> DamageType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHealthComponent", "Kill");

	Params::PhxHealthComponent_Kill Parms{};

	Parms.DamageCauser = DamageCauser;
	Parms.DamageType = DamageType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHealthComponent.SetHealthPct
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewHealthPct                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHealthComponent::SetHealthPct(float NewHealthPct, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHealthComponent", "SetHealthPct");

	Params::PhxHealthComponent_SetHealthPct Parms{};

	Parms.NewHealthPct = NewHealthPct;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHealthComponent.GetHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxHealthComponent::GetHealth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHealthComponent", "GetHealth");

	Params::PhxHealthComponent_GetHealth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHealthComponent.GetHealthPercent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxHealthComponent::GetHealthPercent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHealthComponent", "GetHealthPercent");

	Params::PhxHealthComponent_GetHealthPercent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHealthComponent.IsAlive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxHealthComponent::IsAlive() const
{
	static class UFunction* Func = nullptr;

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

	Params::PhxHealthComponent_IsAlive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterHealthComponent.EndStopBarOnDeath
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterHealthComponent::EndStopBarOnDeath(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthComponent", "EndStopBarOnDeath");

	Params::PhxCharacterHealthComponent_EndStopBarOnDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthComponent.ReceiveFakeHit
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UDamageType>          DamageType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterHealthComponent::ReceiveFakeHit(const struct FVector& Location, const struct FVector& Direction, class FName BoneName, float Damage, TSubclassOf<class UDamageType> DamageType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthComponent", "ReceiveFakeHit");

	Params::PhxCharacterHealthComponent_ReceiveFakeHit Parms{};

	Parms.Location = std::move(Location);
	Parms.Direction = std::move(Direction);
	Parms.BoneName = BoneName;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthComponent.StoppingPowerBarUpdate
// (Final, Native, Public)
// Parameters:
// float                                   StopPower                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DefaultStopPower                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterHealthComponent::StoppingPowerBarUpdate(float StopPower, float DefaultStopPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthComponent", "StoppingPowerBarUpdate");

	Params::PhxCharacterHealthComponent_StoppingPowerBarUpdate Parms{};

	Parms.StopPower = StopPower;
	Parms.DefaultStopPower = DefaultStopPower;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthComponent.IsInjured
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterHealthComponent::IsInjured() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthComponent", "IsInjured");

	Params::PhxCharacterHealthComponent_IsInjured Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.OnDialogLineEnded
// (Final, Native, Private)
// Parameters:
// class AActor*                           SpeakingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDialogueNode&             DialogueNode                                           (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::OnDialogLineEnded(class AActor* SpeakingActor, const struct FDialogueNode& DialogueNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "OnDialogLineEnded");

	Params::PhxCharacterHealthMeterComponent_OnDialogLineEnded Parms{};

	Parms.SpeakingActor = SpeakingActor;
	Parms.DialogueNode = std::move(DialogueNode);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.OnDialogLineStarted
// (Final, Native, Private)
// Parameters:
// class AActor*                           SpeakingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDialogueNode&             DialogueNode                                           (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::OnDialogLineStarted(class AActor* SpeakingActor, const struct FDialogueNode& DialogueNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "OnDialogLineStarted");

	Params::PhxCharacterHealthMeterComponent_OnDialogLineStarted Parms{};

	Parms.SpeakingActor = SpeakingActor;
	Parms.DialogueNode = std::move(DialogueNode);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.OnNotifyReceived
// (Final, Native, Private)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::OnNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "OnNotifyReceived");

	Params::PhxCharacterHealthMeterComponent_OnNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.PlayCircuitEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FCircuitEffectParameters&  EffectParams                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::PlayCircuitEffect(const struct FCircuitEffectParameters& EffectParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "PlayCircuitEffect");

	Params::PhxCharacterHealthMeterComponent_PlayCircuitEffect Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.PlayEdgeGlowEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FEdgeGlowEffectParameters& EffectParams                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::PlayEdgeGlowEffect(const struct FEdgeGlowEffectParameters& EffectParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "PlayEdgeGlowEffect");

	Params::PhxCharacterHealthMeterComponent_PlayEdgeGlowEffect Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.PlayFlashEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFlashEffectParameters&    EffectParams                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::PlayFlashEffect(const struct FFlashEffectParameters& EffectParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "PlayFlashEffect");

	Params::PhxCharacterHealthMeterComponent_PlayFlashEffect Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.PlayOutlineEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FOutlineEffectParameters&  EffectParams                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::PlayOutlineEffect(const struct FOutlineEffectParameters& EffectParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "PlayOutlineEffect");

	Params::PhxCharacterHealthMeterComponent_PlayOutlineEffect Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.ReactToHealthChange
// (Final, Native, Private)
// Parameters:
// class UPhxHealthComponent*              InHealthComp                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterHealthMeterComponent::ReactToHealthChange(class UPhxHealthComponent* InHealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "ReactToHealthChange");

	Params::PhxCharacterHealthMeterComponent_ReactToHealthChange Parms{};

	Parms.InHealthComp = InHealthComp;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.SetupDynamicMaterials
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterHealthMeterComponent::SetupDynamicMaterials()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "SetupDynamicMaterials");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHealthMeterComponent.StopEdgeLightsEffect
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterHealthMeterComponent::StopEdgeLightsEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHealthMeterComponent", "StopEdgeLightsEffect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHeartbeatComponent.OnModifierTagAddedOrRemoved
// (Final, Native, Private)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterHeartbeatComponent::OnModifierTagAddedOrRemoved(const struct FGameplayTag& Tag, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHeartbeatComponent", "OnModifierTagAddedOrRemoved");

	Params::PhxCharacterHeartbeatComponent_OnModifierTagAddedOrRemoved Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterHeartbeatComponent.GetCurrentHeartRate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxCharacterHeartbeatComponent::GetCurrentHeartRate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHeartbeatComponent", "GetCurrentHeartRate");

	Params::PhxCharacterHeartbeatComponent_GetCurrentHeartRate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterHeartbeatComponent.GetNormalizedHeartRate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCharacterHeartbeatComponent::GetNormalizedHeartRate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterHeartbeatComponent", "GetNormalizedHeartRate");

	Params::PhxCharacterHeartbeatComponent_GetNormalizedHeartRate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.AddAnyEntitledItemPacks
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterInventoryComponent::AddAnyEntitledItemPacks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "AddAnyEntitledItemPacks");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.AddItemData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bShowNotification                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOverrideAmount                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::AddItemData(const struct FItemData& ItemData, bool bShowNotification, bool bOverrideAmount, int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "AddItemData");

	Params::PhxCharacterInventoryComponent_AddItemData Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.bShowNotification = bShowNotification;
	Parms.bOverrideAmount = bOverrideAmount;
	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.AddItemDataByName
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Amount                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::AddItemDataByName(const class FName& ItemName, const int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "AddItemDataByName");

	Params::PhxCharacterInventoryComponent_AddItemDataByName Parms{};

	Parms.ItemName = ItemName;
	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.AddNextItemPack
// (Final, Native, Protected)
// Parameters:
// bool                                    bCanAddPack                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::AddNextItemPack(bool bCanAddPack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "AddNextItemPack");

	Params::PhxCharacterInventoryComponent_AddNextItemPack Parms{};

	Parms.bCanAddPack = bCanAddPack;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.AddToViewedItems
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             InName                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::AddToViewedItems(class FName InName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "AddToViewedItems");

	Params::PhxCharacterInventoryComponent_AddToViewedItems Parms{};

	Parms.InName = InName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.AddUploadedSchematics
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FItemData&                 Schematic                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::AddUploadedSchematics(const struct FItemData& Schematic)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "AddUploadedSchematics");

	Params::PhxCharacterInventoryComponent_AddUploadedSchematics Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.ApplyCraftingRecipe
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UPhxCraftingRecipe*         CraftingRecipe                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::ApplyCraftingRecipe(const struct FItemData& ItemData, const class UPhxCraftingRecipe* CraftingRecipe)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "ApplyCraftingRecipe");

	Params::PhxCharacterInventoryComponent_ApplyCraftingRecipe Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.CraftingRecipe = CraftingRecipe;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.ClearStagedEquip
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterInventoryComponent::ClearStagedEquip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "ClearStagedEquip");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.CreateBioInInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class APhxBio>              BioClass                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShowNotification                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxBio*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxBio* UPhxCharacterInventoryComponent::CreateBioInInventory(TSubclassOf<class APhxBio> BioClass, bool bShowNotification)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "CreateBioInInventory");

	Params::PhxCharacterInventoryComponent_CreateBioInInventory Parms{};

	Parms.BioClass = BioClass;
	Parms.bShowNotification = bShowNotification;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.CreateInInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class AEquippable>          EquippableClass                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumOfStacks                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShowNotification                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUnequipOnSpawn                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEquippable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEquippable* UPhxCharacterInventoryComponent::CreateInInventory(TSubclassOf<class AEquippable> EquippableClass, int32 NumOfStacks, bool bShowNotification, bool bUnequipOnSpawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "CreateInInventory");

	Params::PhxCharacterInventoryComponent_CreateInInventory Parms{};

	Parms.EquippableClass = EquippableClass;
	Parms.NumOfStacks = NumOfStacks;
	Parms.bShowNotification = bShowNotification;
	Parms.bUnequipOnSpawn = bUnequipOnSpawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.DestroyAllWeapons
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterInventoryComponent::DestroyAllWeapons()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "DestroyAllWeapons");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.DestroyEquipment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEquippable*                      ToDestroy                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   DestroyAt                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::DestroyEquipment(class AEquippable* ToDestroy, int32 DestroyAt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "DestroyEquipment");

	Params::PhxCharacterInventoryComponent_DestroyEquipment Parms{};

	Parms.ToDestroy = ToDestroy;
	Parms.DestroyAt = DestroyAt;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.DropEquipment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEquippable*                      ToDrop                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UPhxCharacterInventoryComponent::DropEquipment(class AEquippable* ToDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "DropEquipment");

	Params::PhxCharacterInventoryComponent_DropEquipment Parms{};

	Parms.ToDrop = ToDrop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.DropItem
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FItemData&                 ItemToDrop                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::DropItem(const struct FItemData& ItemToDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "DropItem");

	Params::PhxCharacterInventoryComponent_DropItem Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.EquipStaged
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterInventoryComponent::EquipStaged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "EquipStaged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.FindUnlockingSchematic
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FItemData*                       OutSchematic                                           (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::FindUnlockingSchematic(const struct FItemData& InItem, struct FItemData* OutSchematic)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "FindUnlockingSchematic");

	Params::PhxCharacterInventoryComponent_FindUnlockingSchematic Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetAllItemData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<struct FItemData>                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FItemData> UPhxCharacterInventoryComponent::GetAllItemData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetAllItemData");

	Params::PhxCharacterInventoryComponent_GetAllItemData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetDirtyFlag
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::GetDirtyFlag()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetDirtyFlag");

	Params::PhxCharacterInventoryComponent_GetDirtyFlag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetNextUsableConsumable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AConsumable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AConsumable* UPhxCharacterInventoryComponent::GetNextUsableConsumable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetNextUsableConsumable");

	Params::PhxCharacterInventoryComponent_GetNextUsableConsumable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetNextUsableWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EAutoEquipCategory                Type                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEquippable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEquippable* UPhxCharacterInventoryComponent::GetNextUsableWeapon(const EAutoEquipCategory Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetNextUsableWeapon");

	Params::PhxCharacterInventoryComponent_GetNextUsableWeapon Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GiveFullInventorySize
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterInventoryComponent::GiveFullInventorySize()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GiveFullInventorySize");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.HolsterCurrentEquipped
// (Final, Native, Public, BlueprintCallable)

void UPhxCharacterInventoryComponent::HolsterCurrentEquipped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "HolsterCurrentEquipped");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.RemoveItem
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Amount                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::RemoveItem(const class FName& ItemName, const int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "RemoveItem");

	Params::PhxCharacterInventoryComponent_RemoveItem Parms{};

	Parms.ItemName = ItemName;
	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.RemoveItemData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const int32                             Amount                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::RemoveItemData(const struct FItemData& ItemData, const int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "RemoveItemData");

	Params::PhxCharacterInventoryComponent_RemoveItemData Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.RemoveItemInSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const int32                             SlotIndex                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Amount                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::RemoveItemInSlot(const int32 SlotIndex, const int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "RemoveItemInSlot");

	Params::PhxCharacterInventoryComponent_RemoveItemInSlot Parms{};

	Parms.SlotIndex = SlotIndex;
	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.SetDirtyFlag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsDirty                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::SetDirtyFlag(bool bIsDirty)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "SetDirtyFlag");

	Params::PhxCharacterInventoryComponent_SetDirtyFlag Parms{};

	Parms.bIsDirty = bIsDirty;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.SetUploadedSchematics
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FItemData>&         Schematics                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::SetUploadedSchematics(const TArray<struct FItemData>& Schematics)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "SetUploadedSchematics");

	Params::PhxCharacterInventoryComponent_SetUploadedSchematics Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.SetViewedItems
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class FName>&              Items                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::SetViewedItems(const TArray<class FName>& Items)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "SetViewedItems");

	Params::PhxCharacterInventoryComponent_SetViewedItems Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.SetViewedSchematics
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FItemData>&         Schematics                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::SetViewedSchematics(const TArray<struct FItemData>& Schematics)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "SetViewedSchematics");

	Params::PhxCharacterInventoryComponent_SetViewedSchematics Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.SpawnItemInWorld
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FItemData&                 ItemToSpawn                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::SpawnItemInWorld(const struct FItemData& ItemToSpawn, const struct FVector& SpawnLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "SpawnItemInWorld");

	Params::PhxCharacterInventoryComponent_SpawnItemInWorld Parms{};

	Parms.ItemToSpawn = std::move(ItemToSpawn);
	Parms.SpawnLocation = std::move(SpawnLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.StageEquip
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEquippable*                      ToEquip                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::StageEquip(class AEquippable* ToEquip)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "StageEquip");

	Params::PhxCharacterInventoryComponent_StageEquip Parms{};

	Parms.ToEquip = ToEquip;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.SwapRangedWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxRangedWeapon*                 SwapTo                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::SwapRangedWeapon(class APhxRangedWeapon* SwapTo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "SwapRangedWeapon");

	Params::PhxCharacterInventoryComponent_SwapRangedWeapon Parms{};

	Parms.SwapTo = SwapTo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.UpdateLastEquipmentCategories
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEquippable*                      Equip                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::UpdateLastEquipmentCategories(class AEquippable* Equip)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "UpdateLastEquipmentCategories");

	Params::PhxCharacterInventoryComponent_UpdateLastEquipmentCategories Parms{};

	Parms.Equip = Equip;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCharacterInventoryComponent.AutoEquipOnPickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::AutoEquipOnPickup() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "AutoEquipOnPickup");

	Params::PhxCharacterInventoryComponent_AutoEquipOnPickup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.CanAddItem
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   NumberOfStacks                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::CanAddItem(const struct FItemData& ItemData, int32 NumberOfStacks) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "CanAddItem");

	Params::PhxCharacterInventoryComponent_CanAddItem Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.NumberOfStacks = NumberOfStacks;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.CanAffordAndAddItem
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   Discount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberOfStacks                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::CanAffordAndAddItem(const struct FItemData& InItem, float Discount, int32 NumberOfStacks) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "CanAffordAndAddItem");

	Params::PhxCharacterInventoryComponent_CanAffordAndAddItem Parms{};

	Parms.InItem = std::move(InItem);
	Parms.Discount = Discount;
	Parms.NumberOfStacks = NumberOfStacks;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.CanAffordItem
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   Discount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberOfStacks                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::CanAffordItem(const struct FItemData& InItem, float Discount, int32 NumberOfStacks) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "CanAffordItem");

	Params::PhxCharacterInventoryComponent_CanAffordItem Parms{};

	Parms.InItem = std::move(InItem);
	Parms.Discount = Discount;
	Parms.NumberOfStacks = NumberOfStacks;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.CanAffordRecipe
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UPhxCraftingRecipe*         Recipe                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Discount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::CanAffordRecipe(const class UPhxCraftingRecipe* Recipe, float Discount) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "CanAffordRecipe");

	Params::PhxCharacterInventoryComponent_CanAffordRecipe Parms{};

	Parms.Recipe = Recipe;
	Parms.Discount = Discount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.CanRecipeBeCrafted
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UPhxCraftingRecipe*         Recipe                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Discount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::CanRecipeBeCrafted(const struct FItemData& ItemData, const class UPhxCraftingRecipe* Recipe, float Discount) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "CanRecipeBeCrafted");

	Params::PhxCharacterInventoryComponent_CanRecipeBeCrafted Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.Recipe = Recipe;
	Parms.Discount = Discount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.FindItemDataByClass
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UClass*                     PickupClass                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FItemData*                       OutItem                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::FindItemDataByClass(const class UClass* PickupClass, struct FItemData* OutItem) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "FindItemDataByClass");

	Params::PhxCharacterInventoryComponent_FindItemDataByClass Parms{};

	Parms.PickupClass = PickupClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.FindItemDataBySoftClass
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftClassPtr<class UClass>&      InClass                                                (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FItemData*                       OutItem                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::FindItemDataBySoftClass(const TSoftClassPtr<class UClass>& InClass, struct FItemData* OutItem) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "FindItemDataBySoftClass");

	Params::PhxCharacterInventoryComponent_FindItemDataBySoftClass Parms{};

	Parms.InClass = InClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.FindItemWithSlotIndex
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FItemData*                       OutItem                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::FindItemWithSlotIndex(int32 SlotIndex, struct FItemData* OutItem) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "FindItemWithSlotIndex");

	Params::PhxCharacterInventoryComponent_FindItemWithSlotIndex Parms{};

	Parms.SlotIndex = SlotIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.FindRangedWeaponBySoftClass
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftClassPtr<class UClass>&      InClass                                                (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxRangedWeapon*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxRangedWeapon* UPhxCharacterInventoryComponent::FindRangedWeaponBySoftClass(const TSoftClassPtr<class UClass>& InClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "FindRangedWeaponBySoftClass");

	Params::PhxCharacterInventoryComponent_FindRangedWeaponBySoftClass Parms{};

	Parms.InClass = InClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetAllBios
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class APhxBio*>            ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class APhxBio*> UPhxCharacterInventoryComponent::GetAllBios() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetAllBios");

	Params::PhxCharacterInventoryComponent_GetAllBios Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetAllEquipment
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class AEquippable*>        ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class AEquippable*> UPhxCharacterInventoryComponent::GetAllEquipment() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetAllEquipment");

	Params::PhxCharacterInventoryComponent_GetAllEquipment Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetAllUnlockedRecipes
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UPhxCraftingRecipe*>*      OutRecipes                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::GetAllUnlockedRecipes(TArray<class UPhxCraftingRecipe*>* OutRecipes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetAllUnlockedRecipes");

	Params::PhxCharacterInventoryComponent_GetAllUnlockedRecipes Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxCharacterInventoryComponent.GetAllUnlockedRecipesForItem
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UPhxCraftingRecipe*>*      OutRecipes                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::GetAllUnlockedRecipesForItem(const struct FItemData& ItemData, TArray<class UPhxCraftingRecipe*>* OutRecipes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetAllUnlockedRecipesForItem");

	Params::PhxCharacterInventoryComponent_GetAllUnlockedRecipesForItem Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetAvailableQuantity
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   NumberOfStacks                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxCharacterInventoryComponent::GetAvailableQuantity(const struct FItemData& ItemData, int32 NumberOfStacks) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetAvailableQuantity");

	Params::PhxCharacterInventoryComponent_GetAvailableQuantity Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.NumberOfStacks = NumberOfStacks;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetConsumableByCategory
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EItemDataCategory                       ConsumableCategory                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AConsumable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AConsumable* UPhxCharacterInventoryComponent::GetConsumableByCategory(EItemDataCategory ConsumableCategory) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetConsumableByCategory");

	Params::PhxCharacterInventoryComponent_GetConsumableByCategory Parms{};

	Parms.ConsumableCategory = ConsumableCategory;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetEquipmentWithGameplayTag
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEquippable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEquippable* UPhxCharacterInventoryComponent::GetEquipmentWithGameplayTag(const struct FGameplayTag& Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetEquipmentWithGameplayTag");

	Params::PhxCharacterInventoryComponent_GetEquipmentWithGameplayTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEquippable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEquippable* UPhxCharacterInventoryComponent::GetEquipped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetEquipped");

	Params::PhxCharacterInventoryComponent_GetEquipped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetEquippedAux
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEquippable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEquippable* UPhxCharacterInventoryComponent::GetEquippedAux() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetEquippedAux");

	Params::PhxCharacterInventoryComponent_GetEquippedAux Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetItemDataQuantity
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxCharacterInventoryComponent::GetItemDataQuantity(const struct FItemData& ItemData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetItemDataQuantity");

	Params::PhxCharacterInventoryComponent_GetItemDataQuantity Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetItemQuantity
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxCharacterInventoryComponent::GetItemQuantity(const class FName& ItemName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetItemQuantity");

	Params::PhxCharacterInventoryComponent_GetItemQuantity Parms{};

	Parms.ItemName = ItemName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetLastEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EItemDataSubCategory              Category                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEquippable*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEquippable* UPhxCharacterInventoryComponent::GetLastEquipped(const EItemDataSubCategory Category) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetLastEquipped");

	Params::PhxCharacterInventoryComponent_GetLastEquipped Parms{};

	Parms.Category = Category;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetLastEquippedRanged
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxRangedWeapon*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxRangedWeapon* UPhxCharacterInventoryComponent::GetLastEquippedRanged() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetLastEquippedRanged");

	Params::PhxCharacterInventoryComponent_GetLastEquippedRanged Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetPlayerCredits
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxCharacterInventoryComponent::GetPlayerCredits() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetPlayerCredits");

	Params::PhxCharacterInventoryComponent_GetPlayerCredits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetRangedWeapons
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EItemDataSubCategory              Category                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class APhxRangedWeapon*>*        OutRangedWeapons                                       (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::GetRangedWeapons(const EItemDataSubCategory Category, TArray<class APhxRangedWeapon*>* OutRangedWeapons) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetRangedWeapons");

	Params::PhxCharacterInventoryComponent_GetRangedWeapons Parms{};

	Parms.Category = Category;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxCharacterInventoryComponent.GetUnusedSchematics
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EItemDataSubCategory              Category                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FItemData>*               UnusedSchematics                                       (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::GetUnusedSchematics(const EItemDataSubCategory Category, TArray<struct FItemData>* UnusedSchematics) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetUnusedSchematics");

	Params::PhxCharacterInventoryComponent_GetUnusedSchematics Parms{};

	Parms.Category = Category;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxCharacterInventoryComponent.GetUploadedSchematics
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FItemData>          ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FItemData> UPhxCharacterInventoryComponent::GetUploadedSchematics() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetUploadedSchematics");

	Params::PhxCharacterInventoryComponent_GetUploadedSchematics Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetViewedItems
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class FName>               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class FName> UPhxCharacterInventoryComponent::GetViewedItems() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetViewedItems");

	Params::PhxCharacterInventoryComponent_GetViewedItems Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetViewedSchematics
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FItemData>          ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FItemData> UPhxCharacterInventoryComponent::GetViewedSchematics() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetViewedSchematics");

	Params::PhxCharacterInventoryComponent_GetViewedSchematics Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.GetWeaponSchematics
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FItemData>*               OutSchematics                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::GetWeaponSchematics(TArray<struct FItemData>* OutSchematics) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetWeaponSchematics");

	Params::PhxCharacterInventoryComponent_GetWeaponSchematics Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxCharacterInventoryComponent.GetWeaponSchematicsExceptCategory
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FItemData>*               OutSchematics                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const EItemDataCategory                 Category                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCharacterInventoryComponent::GetWeaponSchematicsExceptCategory(TArray<struct FItemData>* OutSchematics, const EItemDataCategory Category) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "GetWeaponSchematicsExceptCategory");

	Params::PhxCharacterInventoryComponent_GetWeaponSchematicsExceptCategory Parms{};

	Parms.Category = Category;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxCharacterInventoryComponent.HasBio
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       BioNameID                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::HasBio(const class FName BioNameID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "HasBio");

	Params::PhxCharacterInventoryComponent_HasBio Parms{};

	Parms.BioNameID = BioNameID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.HasItem
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::HasItem(const struct FItemData& InItem) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "HasItem");

	Params::PhxCharacterInventoryComponent_HasItem Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.HasRangedWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::HasRangedWeapon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "HasRangedWeapon");

	Params::PhxCharacterInventoryComponent_HasRangedWeapon Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.HasSchematicsToUpload
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::HasSchematicsToUpload() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "HasSchematicsToUpload");

	Params::PhxCharacterInventoryComponent_HasSchematicsToUpload Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.HasWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    WeaponSpawnId                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::HasWeapon(const class FString& WeaponSpawnId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "HasWeapon");

	Params::PhxCharacterInventoryComponent_HasWeapon Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.IsBioDecrypted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       BioNameID                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::IsBioDecrypted(const class FName BioNameID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "IsBioDecrypted");

	Params::PhxCharacterInventoryComponent_IsBioDecrypted Parms{};

	Parms.BioNameID = BioNameID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.IsRecipeUnlocked
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UPhxCraftingRecipe*         Recipe                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::IsRecipeUnlocked(const struct FItemData& ItemData, const class UPhxCraftingRecipe* Recipe) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "IsRecipeUnlocked");

	Params::PhxCharacterInventoryComponent_IsRecipeUnlocked Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.Recipe = Recipe;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.ItemHasRecipeApplied
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UPhxCraftingRecipe*         UpgradeRecipe                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::ItemHasRecipeApplied(const struct FItemData& ItemData, const class UPhxCraftingRecipe* UpgradeRecipe) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "ItemHasRecipeApplied");

	Params::PhxCharacterInventoryComponent_ItemHasRecipeApplied Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.UpgradeRecipe = UpgradeRecipe;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCharacterInventoryComponent.ItemRequiresSlotIndex
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 Item                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCharacterInventoryComponent::ItemRequiresSlotIndex(const struct FItemData& Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCharacterInventoryComponent", "ItemRequiresSlotIndex");

	Params::PhxCharacterInventoryComponent_ItemRequiresSlotIndex Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCheatManager.GetAllDLCAnimationsUnlocked
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCheatManager::GetAllDLCAnimationsUnlocked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCheatManager", "GetAllDLCAnimationsUnlocked");

	Params::PhxCheatManager_GetAllDLCAnimationsUnlocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCheatManager.GetDebugHealthBarsEnabled
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCheatManager::GetDebugHealthBarsEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCheatManager", "GetDebugHealthBarsEnabled");

	Params::PhxCheatManager_GetDebugHealthBarsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCheatManager.GetDebugStoppingPowerBarsEnabled
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCheatManager::GetDebugStoppingPowerBarsEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCheatManager", "GetDebugStoppingPowerBarsEnabled");

	Params::PhxCheatManager_GetDebugStoppingPowerBarsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCheatManager.GetRiotModeUIEnabled
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCheatManager::GetRiotModeUIEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCheatManager", "GetRiotModeUIEnabled");

	Params::PhxCheatManager_GetRiotModeUIEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCheatManager.ActivateAllCombatTutorials
// (Final, Exec, Native, Public)

void UPhxCheatManager::ActivateAllCombatTutorials()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "ActivateAllCombatTutorials");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.BugItJira
// (Final, Exec, Native, Public)

void UPhxCheatManager::BugItJira()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "BugItJira");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.DebugSpawnEnemyAtLookAtPos
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FSoftObjectPath&           AICharacterDefinitionPath                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CharacterVariation                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::DebugSpawnEnemyAtLookAtPos(const struct FSoftObjectPath& AICharacterDefinitionPath, int32 CharacterVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "DebugSpawnEnemyAtLookAtPos");

	Params::PhxCheatManager_DebugSpawnEnemyAtLookAtPos Parms{};

	Parms.AICharacterDefinitionPath = std::move(AICharacterDefinitionPath);
	Parms.CharacterVariation = CharacterVariation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.HandleAISpawnedForPairedKill
// (Final, Native, Private)
// Parameters:
// class APhxAICharacter*                  SpawnedAI                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAISpawnResultCode                   ResultCode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SpawnUid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::HandleAISpawnedForPairedKill(class APhxAICharacter* SpawnedAI, EPhxAISpawnResultCode ResultCode, int32 SpawnUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "HandleAISpawnedForPairedKill");

	Params::PhxCheatManager_HandleAISpawnedForPairedKill Parms{};

	Parms.SpawnedAI = SpawnedAI;
	Parms.ResultCode = ResultCode;
	Parms.SpawnUid = SpawnUid;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.LogCheckpointedData
// (Final, Exec, Native, Public)

void UPhxCheatManager::LogCheckpointedData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "LogCheckpointedData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.MarkCurrentGameProgressComplete
// (Final, Exec, Native, Public)

void UPhxCheatManager::MarkCurrentGameProgressComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "MarkCurrentGameProgressComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.ModifyObjectProperty
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ObjectName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PropertyName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NewPropertyValue1                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NewPropertyValue2                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NewPropertyValue3                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::ModifyObjectProperty(const class FString& ObjectName, const class FString& PropertyName, float NewPropertyValue1, float NewPropertyValue2, float NewPropertyValue3)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "ModifyObjectProperty");

	Params::PhxCheatManager_ModifyObjectProperty Parms{};

	Parms.ObjectName = std::move(ObjectName);
	Parms.PropertyName = std::move(PropertyName);
	Parms.NewPropertyValue1 = NewPropertyValue1;
	Parms.NewPropertyValue2 = NewPropertyValue2;
	Parms.NewPropertyValue3 = NewPropertyValue3;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.OnCheatScriptedEventCharacterFreed
// (Final, Native, Public, HasOutParams)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      BindingTag                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::OnCheatScriptedEventCharacterFreed(class APhxCharacter* Character, const class FName& BindingTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "OnCheatScriptedEventCharacterFreed");

	Params::PhxCheatManager_OnCheatScriptedEventCharacterFreed Parms{};

	Parms.Character = Character;
	Parms.BindingTag = BindingTag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.OnCheatScriptedEventFinished
// (Final, Native, Public)

void UPhxCheatManager::OnCheatScriptedEventFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "OnCheatScriptedEventFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.PilotCamGo
// (Final, Exec, Native, Public)
// Parameters:
// float                                   X                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Y                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Z                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Pitch                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Yaw                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Roll                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::PilotCamGo(float X, float Y, float Z, float Pitch, float Yaw, float Roll)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "PilotCamGo");

	Params::PhxCheatManager_PilotCamGo Parms{};

	Parms.X = X;
	Parms.Y = Y;
	Parms.Z = Z;
	Parms.Pitch = Pitch;
	Parms.Yaw = Yaw;
	Parms.Roll = Roll;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.PS5HapticDisable
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   TriggerSide                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::PS5HapticDisable(int32 TriggerSide)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "PS5HapticDisable");

	Params::PhxCheatManager_PS5HapticDisable Parms{};

	Parms.TriggerSide = TriggerSide;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.PS5HapticFeedbackMode
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   TriggerSide                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::PS5HapticFeedbackMode(int32 TriggerSide, int32 Position, int32 Strength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "PS5HapticFeedbackMode");

	Params::PhxCheatManager_PS5HapticFeedbackMode Parms{};

	Parms.TriggerSide = TriggerSide;
	Parms.Position = Position;
	Parms.Strength = Strength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.PS5HapticVibrationMode
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   TriggerSide                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Frequency                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Amplitude                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::PS5HapticVibrationMode(int32 TriggerSide, int32 Position, int32 Frequency, int32 Amplitude)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "PS5HapticVibrationMode");

	Params::PhxCheatManager_PS5HapticVibrationMode Parms{};

	Parms.TriggerSide = TriggerSide;
	Parms.Position = Position;
	Parms.Frequency = Frequency;
	Parms.Amplitude = Amplitude;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.PS5HapticWeaponMode
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   TriggerSide                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   StartPos                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   EndPos                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::PS5HapticWeaponMode(int32 TriggerSide, int32 StartPos, int32 EndPos, int32 Strength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "PS5HapticWeaponMode");

	Params::PhxCheatManager_PS5HapticWeaponMode Parms{};

	Parms.TriggerSide = TriggerSide;
	Parms.StartPos = StartPos;
	Parms.EndPos = EndPos;
	Parms.Strength = Strength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.SetOnlineStatus
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bOnline                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::SetOnlineStatus(bool bOnline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "SetOnlineStatus");

	Params::PhxCheatManager_SetOnlineStatus Parms{};

	Parms.bOnline = bOnline;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.StreamGlobalLevelIn
// (Exec, Native, Public)
// Parameters:
// class FName                             Map                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::StreamGlobalLevelIn(class FName Map, class FName Section)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "StreamGlobalLevelIn");

	Params::PhxCheatManager_StreamGlobalLevelIn Parms{};

	Parms.Map = Map;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.StreamGlobalLevelOut
// (Exec, Native, Public)
// Parameters:
// class FName                             Map                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::StreamGlobalLevelOut(class FName Map, class FName Section)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "StreamGlobalLevelOut");

	Params::PhxCheatManager_StreamGlobalLevelOut Parms{};

	Parms.Map = Map;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.StreamLevelSectionIn
// (Exec, Native, Public)
// Parameters:
// class FName                             Map                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Subsection                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::StreamLevelSectionIn(class FName Map, class FName Section, class FName Subsection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "StreamLevelSectionIn");

	Params::PhxCheatManager_StreamLevelSectionIn Parms{};

	Parms.Map = Map;
	Parms.Section = Section;
	Parms.Subsection = Subsection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.StreamLevelSectionOut
// (Exec, Native, Public)
// Parameters:
// class FName                             Map                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Subsection                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::StreamLevelSectionOut(class FName Map, class FName Section, class FName Subsection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "StreamLevelSectionOut");

	Params::PhxCheatManager_StreamLevelSectionOut Parms{};

	Parms.Map = Map;
	Parms.Section = Section;
	Parms.Subsection = Subsection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.ToggleHealthBars
// (Final, Exec, Native, Public)

void UPhxCheatManager::ToggleHealthBars()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "ToggleHealthBars");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.ToggleInputDebugger
// (Final, Exec, Native, Public)

void UPhxCheatManager::ToggleInputDebugger()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "ToggleInputDebugger");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.ToggleLightShadows
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    LightName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::ToggleLightShadows(const class FString& LightName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "ToggleLightShadows");

	Params::PhxCheatManager_ToggleLightShadows Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.ToggleSpikeWallCollisionDebug
// (Final, Exec, Native, Public)

void UPhxCheatManager::ToggleSpikeWallCollisionDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "ToggleSpikeWallCollisionDebug");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.ToggleStoppingPowerBars
// (Final, Exec, Native, Public)

void UPhxCheatManager::ToggleStoppingPowerBars()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "ToggleStoppingPowerBars");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.TriggerAutoSave
// (Final, Exec, Native, Public)

void UPhxCheatManager::TriggerAutoSave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "TriggerAutoSave");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.UnloadStreamingLevel
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             StreamingLevelName                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCheatManager::UnloadStreamingLevel(class FName StreamingLevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "UnloadStreamingLevel");

	Params::PhxCheatManager_UnloadStreamingLevel Parms{};

	Parms.StreamingLevelName = StreamingLevelName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCheatManager.IsInputDebuggerActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCheatManager::IsInputDebuggerActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "IsInputDebuggerActive");

	Params::PhxCheatManager_IsInputDebuggerActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCheatManager.IsMarketingCameraHudActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCheatManager::IsMarketingCameraHudActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "IsMarketingCameraHudActive");

	Params::PhxCheatManager_IsMarketingCameraHudActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCheatManager.IsSpeedThroughToggleEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCheatManager::IsSpeedThroughToggleEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCheatManager", "IsSpeedThroughToggleEnabled");

	Params::PhxCheatManager_IsSpeedThroughToggleEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSQuickSwapHandler.QuickSwapCancel
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSQuickSwapHandler::QuickSwapCancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSQuickSwapHandler", "QuickSwapCancel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSQuickSwapHandler.QuickSwapDirectionInput
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ISDSQuickSwapHandler::QuickSwapDirectionInput(EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSQuickSwapHandler", "QuickSwapDirectionInput");

	Params::SDSQuickSwapHandler_QuickSwapDirectionInput Parms{};

	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSQuickSwapHandler.QuickSwapEquip
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSQuickSwapHandler::QuickSwapEquip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSQuickSwapHandler", "QuickSwapEquip");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSPromptWidget.SetMessage
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSPromptWidget::SetMessage(const class FText& InMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSPromptWidget", "SetMessage");

	Params::SDSPromptWidget_SetMessage Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SheenComponent.CreateDynamicSheenMaterials
// (Final, Native, Protected)

void USheenComponent::CreateDynamicSheenMaterials()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheenComponent", "CreateDynamicSheenMaterials");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SheenComponent.CreateSheenMesh_Skeletal
// (Final, Native, Protected)
// Parameters:
// class USkeletalMeshComponent*           SkeletalMeshComp                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USheenComponent::CreateSheenMesh_Skeletal(class USkeletalMeshComponent* SkeletalMeshComp, int32 ID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheenComponent", "CreateSheenMesh_Skeletal");

	Params::SheenComponent_CreateSheenMesh_Skeletal Parms{};

	Parms.SkeletalMeshComp = SkeletalMeshComp;
	Parms.ID = ID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SheenComponent.CreateSheenMesh_Static
// (Final, Native, Protected)
// Parameters:
// class UStaticMeshComponent*             StaticMeshComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USheenComponent::CreateSheenMesh_Static(class UStaticMeshComponent* StaticMeshComp, int32 ID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheenComponent", "CreateSheenMesh_Static");

	Params::SheenComponent_CreateSheenMesh_Static Parms{};

	Parms.StaticMeshComp = StaticMeshComp;
	Parms.ID = ID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SheenComponent.CreateSheenMeshes
// (Final, Native, Protected)

void USheenComponent::CreateSheenMeshes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheenComponent", "CreateSheenMeshes");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SheenComponent.DisableSheen
// (Final, Native, Public, BlueprintCallable)

void USheenComponent::DisableSheen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheenComponent", "DisableSheen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SheenComponent.EnableSheen
// (Final, Native, Public, BlueprintCallable)

void USheenComponent::EnableSheen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheenComponent", "EnableSheen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SheenComponent.SetSheenIntensity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             Value                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("SheenComponent", "SetSheenIntensity");

	Params::SheenComponent_SetSheenIntensity Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SessionListWidget.BeginServerSearch
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bLANMatch                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsDedicatedServer                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InMapFilterName                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USessionListWidget::BeginServerSearch(bool bLANMatch, bool bIsDedicatedServer, const class FString& InMapFilterName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SessionListWidget", "BeginServerSearch");

	Params::SessionListWidget_BeginServerSearch Parms{};

	Parms.bLANMatch = bLANMatch;
	Parms.bIsDedicatedServer = bIsDedicatedServer;
	Parms.InMapFilterName = std::move(InMapFilterName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SessionListWidget.ConnectToServer
// (Final, Native, Public, BlueprintCallable)

void USessionListWidget::ConnectToServer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SessionListWidget", "ConnectToServer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SessionListWidget.UpdateSearchStatus
// (Final, Native, Public, BlueprintCallable)

void USessionListWidget::UpdateSearchStatus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SessionListWidget", "UpdateSearchStatus");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SessionListWidget.UpdateSessionList
// (Final, Native, Public, BlueprintCallable)

void USessionListWidget::UpdateSessionList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SessionListWidget", "UpdateSessionList");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnAnimMontageStartedForLevelSequenceActor0
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCinematicsComponent::OnAnimMontageStartedForLevelSequenceActor0(class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnAnimMontageStartedForLevelSequenceActor0");

	Params::PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor0 Parms{};

	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnAnimMontageStartedForLevelSequenceActor1
// (Final, Native, Private)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCinematicsComponent::OnAnimMontageStartedForLevelSequenceActor1(class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnAnimMontageStartedForLevelSequenceActor1");

	Params::PhxCinematicsComponent_OnAnimMontageStartedForLevelSequenceActor1 Parms{};

	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnCharacterDeath
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCinematicsComponent::OnCharacterDeath(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnCharacterDeath");

	Params::PhxCinematicsComponent_OnCharacterDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnLevelSequenceFinishedForLevelSequenceActor0
// (Final, Native, Private)

void UPhxCinematicsComponent::OnLevelSequenceFinishedForLevelSequenceActor0()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnLevelSequenceFinishedForLevelSequenceActor0");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnLevelSequenceFinishedForLevelSequenceActor1
// (Final, Native, Private)

void UPhxCinematicsComponent::OnLevelSequenceFinishedForLevelSequenceActor1()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnLevelSequenceFinishedForLevelSequenceActor1");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnLevelSequenceFinishedReversePlaybackForLevelSequenceActor0
// (Final, Native, Private)

void UPhxCinematicsComponent::OnLevelSequenceFinishedReversePlaybackForLevelSequenceActor0()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnLevelSequenceFinishedReversePlaybackForLevelSequenceActor0");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnLevelSequenceFinishedReversePlaybackForLevelSequenceActor1
// (Final, Native, Private)

void UPhxCinematicsComponent::OnLevelSequenceFinishedReversePlaybackForLevelSequenceActor1()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnLevelSequenceFinishedReversePlaybackForLevelSequenceActor1");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.OnParticipantSpawned
// (Final, Native, Public)
// Parameters:
// class APhxAICharacter*                  SpawnedAI                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAISpawnResultCode                   ResultCode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SpawnUid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCinematicsComponent::OnParticipantSpawned(class APhxAICharacter* SpawnedAI, EPhxAISpawnResultCode ResultCode, int32 SpawnUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "OnParticipantSpawned");

	Params::PhxCinematicsComponent_OnParticipantSpawned Parms{};

	Parms.SpawnedAI = SpawnedAI;
	Parms.ResultCode = ResultCode;
	Parms.SpawnUid = SpawnUid;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.SetRootOverrideLevelSequenceIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   OverrideIndex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCinematicsComponent::SetRootOverrideLevelSequenceIndex(int32 OverrideIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "SetRootOverrideLevelSequenceIndex");

	Params::PhxCinematicsComponent_SetRootOverrideLevelSequenceIndex Parms{};

	Parms.OverrideIndex = OverrideIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCinematicsComponent.GetCurrentLevelSequenceActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ALevelSequenceActor*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ALevelSequenceActor* UPhxCinematicsComponent::GetCurrentLevelSequenceActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "GetCurrentLevelSequenceActor");

	Params::PhxCinematicsComponent_GetCurrentLevelSequenceActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCinematicsComponent.GetFinalBlendTime
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxCinematicsComponent::GetFinalBlendTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCinematicsComponent", "GetFinalBlendTime");

	Params::PhxCinematicsComponent_GetFinalBlendTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2PrintState.CharacterNotify
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterV2PrintState::CharacterNotify(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2PrintState", "CharacterNotify");

	Params::PrinterV2PrintState_CharacterNotify Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2PrintState.OnScriptedEventStarted
// (Final, Native, Protected)

void UPrinterV2PrintState::OnScriptedEventStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2PrintState", "OnScriptedEventStarted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2PrintState.PrinterNotify
// (Final, Native, Protected)
// Parameters:
// const class UPhxPrinterAnimNotify*      Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterV2PrintState::PrinterNotify(const class UPhxPrinterAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2PrintState", "PrinterNotify");

	Params::PrinterV2PrintState_PrinterNotify Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_EquipWeapon.OnEquipMontageFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_EquipWeapon::OnEquipMontageFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_EquipWeapon", "OnEquipMontageFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_EquipWeapon.OnEquipMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_EquipWeapon::OnEquipMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_EquipWeapon", "OnEquipMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_EquipWeapon.OnNotifyReceived
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             AnimNotify                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_EquipWeapon::OnNotifyReceived(const class UPhxAnimNotify* AnimNotify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_EquipWeapon", "OnNotifyReceived");

	Params::PhxGameplayAbility_EquipWeapon_OnNotifyReceived Parms{};

	Parms.AnimNotify = AnimNotify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_EquipWeapon.OnUnequipTagRemoved
// (Native, Protected)

void UPhxGameplayAbility_EquipWeapon::OnUnequipTagRemoved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_EquipWeapon", "OnUnequipTagRemoved");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2FSM.InteractExecuted
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterV2FSM::InteractExecuted(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2FSM", "InteractExecuted");

	Params::PrinterV2FSM_InteractExecuted Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2FSM.OnScriptedEventCharacterFreed
// (Final, Native, Private, HasOutParams)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      BindingTag                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterV2FSM::OnScriptedEventCharacterFreed(class APhxCharacter* Character, const class FName& BindingTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2FSM", "OnScriptedEventCharacterFreed");

	Params::PrinterV2FSM_OnScriptedEventCharacterFreed Parms{};

	Parms.Character = Character;
	Parms.BindingTag = BindingTag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2FSM.OnScriptedEventFinish
// (Final, Native, Private)

void UPrinterV2FSM::OnScriptedEventFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2FSM", "OnScriptedEventFinish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyLaunch.OnEnemyHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyLaunch", "OnEnemyHit");

	Params::PhxGameplayAbility_GRPEnemyLaunch_OnEnemyHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyLaunch.OnFinalMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_GRPEnemyLaunch::OnFinalMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyLaunch", "OnFinalMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyLaunch.OnMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_GRPEnemyLaunch::OnMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyLaunch", "OnMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCombatSubsystem.RegisterPlayerDeathHideActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           HideActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCombatSubsystem::RegisterPlayerDeathHideActor(class AActor* HideActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCombatSubsystem", "RegisterPlayerDeathHideActor");

	Params::PhxCombatSubsystem_RegisterPlayerDeathHideActor Parms{};

	Parms.HideActor = HideActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCombatSubsystem.UnregisterPlayerDeathHideActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           HideActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCombatSubsystem::UnregisterPlayerDeathHideActor(class AActor* HideActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCombatSubsystem", "UnregisterPlayerDeathHideActor");

	Params::PhxCombatSubsystem_UnregisterPlayerDeathHideActor Parms{};

	Parms.HideActor = HideActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCredits.ReadCreditsToDataTable
// (Final, Native, Public)

void APhxCredits::ReadCreditsToDataTable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCredits", "ReadCreditsToDataTable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCustomizationManager.AreAllSkinsUnlockedViaCheat
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxCustomizationManager::AreAllSkinsUnlockedViaCheat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCustomizationManager", "AreAllSkinsUnlockedViaCheat");

	Params::PhxCustomizationManager_AreAllSkinsUnlockedViaCheat Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCustomizationManager.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxCustomizationManager*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCustomizationManager* UPhxCustomizationManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCustomizationManager", "Get");

	Params::PhxCustomizationManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCustomizationManager.GetSkinEntitlementId
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UPhxCharacterSkin*                Skin                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxEntitlement                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxEntitlement UPhxCustomizationManager::GetSkinEntitlementId(class UPhxCharacterSkin* Skin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxCustomizationManager", "GetSkinEntitlementId");

	Params::PhxCustomizationManager_GetSkinEntitlementId Parms{};

	Parms.Skin = Skin;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCustomizationManager.OnAccountChanged
// (Final, Native, Public)
// Parameters:
// class USDSOnlineAccount*                NewAccount                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCustomizationManager::OnAccountChanged(class USDSOnlineAccount* NewAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCustomizationManager", "OnAccountChanged");

	Params::PhxCustomizationManager_OnAccountChanged Parms{};

	Parms.NewAccount = NewAccount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCustomizationManager.OnSkinValidationResultReceived
// (Final, Native, Public)
// Parameters:
// bool                                    bHasEntitlement                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCustomizationManager::OnSkinValidationResultReceived(bool bHasEntitlement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCustomizationManager", "OnSkinValidationResultReceived");

	Params::PhxCustomizationManager_OnSkinValidationResultReceived Parms{};

	Parms.bHasEntitlement = bHasEntitlement;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCustomizationManager.SetPlayerSkinIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   SkinIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxCustomizationManager::SetPlayerSkinIndex(int32 SkinIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCustomizationManager", "SetPlayerSkinIndex");

	Params::PhxCustomizationManager_SetPlayerSkinIndex Parms{};

	Parms.SkinIndex = SkinIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCustomizationManager.ValidateCurrentSkinEntittlement
// (Final, Native, Public, BlueprintCallable)

void UPhxCustomizationManager::ValidateCurrentSkinEntittlement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCustomizationManager", "ValidateCurrentSkinEntittlement");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxCustomizationManager.GetActivePlayerSkin
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxCharacterSkin*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCharacterSkin* UPhxCustomizationManager::GetActivePlayerSkin() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCustomizationManager", "GetActivePlayerSkin");

	Params::PhxCustomizationManager_GetActivePlayerSkin Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxCustomizationManager.GetCurrentPlayerSkinIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxCustomizationManager::GetCurrentPlayerSkinIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxCustomizationManager", "GetCurrentPlayerSkinIndex");

	Params::PhxCustomizationManager_GetCurrentPlayerSkinIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDebugCamera.DumpCameraInfo
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDebugCamera::DumpCameraInfo(const class FString& Filename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugCamera", "DumpCameraInfo");

	Params::PhxDebugCamera_DumpCameraInfo Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDebugCameraDrawing.DrawAxes
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ColorScale                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDebugCameraDrawing::DrawAxes(class UObject* World, const struct FVector& Location, const struct FRotator& Rotation, float Thickness, float Scale, float ColorScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugCameraDrawing", "DrawAxes");

	Params::PhxDebugCameraDrawing_DrawAxes Parms{};

	Parms.World = World;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.Thickness = Thickness;
	Parms.Scale = Scale;
	Parms.ColorScale = ColorScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDebugCameraDrawing.DrawFrustum
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   fieldOfView                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ScreenRatio                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NearClip                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FarClip                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDebugCameraDrawing::DrawFrustum(class UObject* World, const struct FVector& Location, const struct FRotator& Rotation, float fieldOfView, float ScreenRatio, float NearClip, float FarClip, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugCameraDrawing", "DrawFrustum");

	Params::PhxDebugCameraDrawing_DrawFrustum Parms{};

	Parms.World = World;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.fieldOfView = fieldOfView;
	Parms.ScreenRatio = ScreenRatio;
	Parms.NearClip = NearClip;
	Parms.FarClip = FarClip;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDebugCameraDrawing.DrawFrustumCollision
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   fieldOfView                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ScreenRatio                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NearClip                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FarClip                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDebugCameraDrawing::DrawFrustumCollision(class UObject* World, const struct FVector& Location, const struct FRotator& Rotation, float fieldOfView, float ScreenRatio, float NearClip, float FarClip, float Thickness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugCameraDrawing", "DrawFrustumCollision");

	Params::PhxDebugCameraDrawing_DrawFrustumCollision Parms{};

	Parms.World = World;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.fieldOfView = fieldOfView;
	Parms.ScreenRatio = ScreenRatio;
	Parms.NearClip = NearClip;
	Parms.FarClip = FarClip;
	Parms.Thickness = Thickness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDebugCameraDrawing.DrawOutlinedText
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Text                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  ViewRotation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              TextColor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              OutlineColor                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OutlineOffset                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDebugCameraDrawing::DrawOutlinedText(class UObject* World, const class FString& Text, const struct FVector& Location, const struct FRotator& ViewRotation, const struct FLinearColor& TextColor, const struct FLinearColor& OutlineColor, float OutlineOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDebugCameraDrawing", "DrawOutlinedText");

	Params::PhxDebugCameraDrawing_DrawOutlinedText Parms{};

	Parms.World = World;
	Parms.Text = std::move(Text);
	Parms.Location = std::move(Location);
	Parms.ViewRotation = std::move(ViewRotation);
	Parms.TextColor = std::move(TextColor);
	Parms.OutlineColor = std::move(OutlineColor);
	Parms.OutlineOffset = OutlineOffset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueEvent.GetCurrentlySpeakingActor
// (Final, Native, Public)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UPhxDialogueEvent::GetCurrentlySpeakingActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "GetCurrentlySpeakingActor");

	Params::PhxDialogueEvent_GetCurrentlySpeakingActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDialogueEvent.GetSoundComponent
// (Final, Native, Public)
// Parameters:
// class UPhxSoundComponent*               ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSoundComponent* UPhxDialogueEvent::GetSoundComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "GetSoundComponent");

	Params::PhxDialogueEvent_GetSoundComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDialogueEvent.OnLipflapLoadComplete
// (Final, Native, Private)

void UPhxDialogueEvent::OnLipflapLoadComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "OnLipflapLoadComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueEvent.OnSoundEventCallback
// (Final, Native, Public)
// Parameters:
// EAkCallbackType                         CallbackType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  CallbackInfo                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueEvent::OnSoundEventCallback(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "OnSoundEventCallback");

	Params::PhxDialogueEvent_OnSoundEventCallback Parms{};

	Parms.CallbackType = CallbackType;
	Parms.CallbackInfo = CallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueEvent.PausePhxSoundEvent
// (Final, Native, Public)
// Parameters:
// int32                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueEvent::PausePhxSoundEvent(int32 FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "PausePhxSoundEvent");

	Params::PhxDialogueEvent_PausePhxSoundEvent Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueEvent.PostPhxSoundEvent
// (Final, Native, Public)

void UPhxDialogueEvent::PostPhxSoundEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "PostPhxSoundEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueEvent.ResumePhxSoundEvent
// (Final, Native, Public)
// Parameters:
// int32                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueEvent::ResumePhxSoundEvent(int32 FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "ResumePhxSoundEvent");

	Params::PhxDialogueEvent_ResumePhxSoundEvent Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueEvent.StopPhxSoundEvent
// (Final, Native, Public)
// Parameters:
// int32                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueEvent::StopPhxSoundEvent(int32 FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "StopPhxSoundEvent");

	Params::PhxDialogueEvent_StopPhxSoundEvent Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueEvent.TimedEndOfEvent
// (Final, Native, Private)

void UPhxDialogueEvent::TimedEndOfEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueEvent", "TimedEndOfEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxDialogueManager*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxDialogueManager* UPhxDialogueManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxDialogueManager", "Get");

	Params::PhxDialogueManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDialogueManager.AreSubtitlesDisabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDialogueManager::AreSubtitlesDisabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "AreSubtitlesDisabled");

	Params::PhxDialogueManager_AreSubtitlesDisabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDialogueManager.ClearBinkSubtitle
// (Final, Native, Public, BlueprintCallable)

void UPhxDialogueManager::ClearBinkSubtitle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "ClearBinkSubtitle");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.HideDialogWidgetFromView
// (Final, Native, Public, BlueprintCallable)

void UPhxDialogueManager::HideDialogWidgetFromView()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "HideDialogWidgetFromView");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnCombatStateChanged
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         PreviousGameState                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         NewGameState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnCombatStateChanged(class UPhxAIGameStateManager* GameStateManager, EPhxAIGameState PreviousGameState, EPhxAIGameState NewGameState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnCombatStateChanged");

	Params::PhxDialogueManager_OnCombatStateChanged Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.PreviousGameState = PreviousGameState;
	Parms.NewGameState = NewGameState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnEnemyDied
// (Final, Native, Protected)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnEnemyDied(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnEnemyDied");

	Params::PhxDialogueManager_OnEnemyDied Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnEnemyMutated
// (Final, Native, Protected)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnEnemyMutated(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnEnemyMutated");

	Params::PhxDialogueManager_OnEnemyMutated Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnLastEncounterEnemyDied
// (Final, Native, Protected)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnLastEncounterEnemyDied(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnLastEncounterEnemyDied");

	Params::PhxDialogueManager_OnLastEncounterEnemyDied Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnPlayerFiredWeapon
// (Final, Native, Protected)
// Parameters:
// class APhxPlayerCharacter*              Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxGunWeapon*                    Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnPlayerFiredWeapon(class APhxPlayerCharacter* Player, class APhxGunWeapon* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnPlayerFiredWeapon");

	Params::PhxDialogueManager_OnPlayerFiredWeapon Parms{};

	Parms.Player = Player;
	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnPlayerFocusTargetChanged
// (Final, Native, Protected)
// Parameters:
// class APhxPlayerCharacter*              Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           PreviousFocusTarget                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           NewFocusTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnPlayerFocusTargetChanged(class APhxPlayerCharacter* Player, class AActor* PreviousFocusTarget, class AActor* NewFocusTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnPlayerFocusTargetChanged");

	Params::PhxDialogueManager_OnPlayerFocusTargetChanged Parms{};

	Parms.Player = Player;
	Parms.PreviousFocusTarget = PreviousFocusTarget;
	Parms.NewFocusTarget = NewFocusTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnPlayerInteractionExecuted
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractingCharacter                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInteraction*               Interaction                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnPlayerInteractionExecuted(class APhxCharacter* InteractingCharacter, const class UInteraction* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnPlayerInteractionExecuted");

	Params::PhxDialogueManager_OnPlayerInteractionExecuted Parms{};

	Parms.InteractingCharacter = InteractingCharacter;
	Parms.Interaction = Interaction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnPlayerScriptedEventEnd
// (Final, Native, Public)

void UPhxDialogueManager::OnPlayerScriptedEventEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnPlayerScriptedEventEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnPlayerScriptedEventStart
// (Final, Native, Public)

void UPhxDialogueManager::OnPlayerScriptedEventStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnPlayerScriptedEventStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.OnSoundEventEnd
// (Final, Native, Private)
// Parameters:
// class UPhxDialogueEvent*                DialogueEvent                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::OnSoundEventEnd(class UPhxDialogueEvent* DialogueEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "OnSoundEventEnd");

	Params::PhxDialogueManager_OnSoundEventEnd Parms{};

	Parms.DialogueEvent = DialogueEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.UpdateBinkSubtitle
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FBinkSubtitleRow&          InRow                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxDialogueManager::UpdateBinkSubtitle(const struct FBinkSubtitleRow& InRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "UpdateBinkSubtitle");

	Params::PhxDialogueManager_UpdateBinkSubtitle Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueManager.UpdateSubtitles
// (Final, Native, Public)
// Parameters:
// class UPhxDialogueEvent*                DialogueEvent                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueManager::UpdateSubtitles(class UPhxDialogueEvent* DialogueEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueManager", "UpdateSubtitles");

	Params::PhxDialogueManager_UpdateSubtitles Parms{};

	Parms.DialogueEvent = DialogueEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueWorldSubsystem.PauseAudioLog
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InAudioLog                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueWorldSubsystem::PauseAudioLog(class UDialogue* InAudioLog)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueWorldSubsystem", "PauseAudioLog");

	Params::PhxDialogueWorldSubsystem_PauseAudioLog Parms{};

	Parms.InAudioLog = InAudioLog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueWorldSubsystem.PlayAudioLog
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InAudioLog                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Speaker                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueWorldSubsystem::PlayAudioLog(class UDialogue* InAudioLog, class AActor* Speaker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueWorldSubsystem", "PlayAudioLog");

	Params::PhxDialogueWorldSubsystem_PlayAudioLog Parms{};

	Parms.InAudioLog = InAudioLog;
	Parms.Speaker = Speaker;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueWorldSubsystem.PlayDialogue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InDialogue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           SpeakingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueWorldSubsystem::PlayDialogue(class UDialogue* InDialogue, class AActor* SpeakingActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueWorldSubsystem", "PlayDialogue");

	Params::PhxDialogueWorldSubsystem_PlayDialogue Parms{};

	Parms.InDialogue = InDialogue;
	Parms.SpeakingActor = SpeakingActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueWorldSubsystem.StopAudioLog
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InAudioLog                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueWorldSubsystem::StopAudioLog(class UDialogue* InAudioLog)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueWorldSubsystem", "StopAudioLog");

	Params::PhxDialogueWorldSubsystem_StopAudioLog Parms{};

	Parms.InAudioLog = InAudioLog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDialogueWorldSubsystem.TestCombatStateChange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         PreviousGameState                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         NewGameState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDialogueWorldSubsystem::TestCombatStateChange(class UPhxAIGameStateManager* GameStateManager, EPhxAIGameState PreviousGameState, EPhxAIGameState NewGameState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDialogueWorldSubsystem", "TestCombatStateChange");

	Params::PhxDialogueWorldSubsystem_TestCombatStateChange Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.PreviousGameState = PreviousGameState;
	Parms.NewGameState = NewGameState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDynamicDropsActor.OnTriggerOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxDynamicDropsActor::OnTriggerOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDynamicDropsActor", "OnTriggerOverlap");

	Params::PhxDynamicDropsActor_OnTriggerOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDynamicDropsActor.ScanForNearbySpawnNodes
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxDynamicDropsActor::ScanForNearbySpawnNodes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDynamicDropsActor", "ScanForNearbySpawnNodes");

	Params::PhxDynamicDropsActor_ScanForNearbySpawnNodes Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDynamicDropsActor.SpawnLoot
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class APhxPlayerCharacter*              Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxDynamicDropsActor::SpawnLoot(class APhxPlayerCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDynamicDropsActor", "SpawnLoot");

	Params::PhxDynamicDropsActor_SpawnLoot Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDynamicDropsComponent.OnOwnerDeath
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    CharacterOwner                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxDynamicDropsComponent::OnOwnerDeath(class APhxCharacter* CharacterOwner, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDynamicDropsComponent", "OnOwnerDeath");

	Params::PhxDynamicDropsComponent_OnOwnerDeath Parms{};

	Parms.CharacterOwner = CharacterOwner;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxDynamicDropsComponent.SpawnLootAtLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class APhxPlayerCharacter*              Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ItemLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  ItemRotation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class APickup*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickup* UPhxDynamicDropsComponent::SpawnLootAtLocation(class APhxPlayerCharacter* Character, const struct FVector& ItemLocation, const struct FRotator& ItemRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDynamicDropsComponent", "SpawnLootAtLocation");

	Params::PhxDynamicDropsComponent_SpawnLootAtLocation Parms{};

	Parms.Character = Character;
	Parms.ItemLocation = std::move(ItemLocation);
	Parms.ItemRotation = std::move(ItemRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDynamicDropsComponent.SpawnLootWithArcMotion
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class APhxPlayerCharacter*              Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ItemLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  ItemRotation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class APickup*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickup* UPhxDynamicDropsComponent::SpawnLootWithArcMotion(class APhxPlayerCharacter* Character, const struct FVector& ItemLocation, const struct FRotator& ItemRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDynamicDropsComponent", "SpawnLootWithArcMotion");

	Params::PhxDynamicDropsComponent_SpawnLootWithArcMotion Parms{};

	Parms.Character = Character;
	Parms.ItemLocation = std::move(ItemLocation);
	Parms.ItemRotation = std::move(ItemRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxDynamicDropsComponent.ShouldDropLoot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxDynamicDropsComponent::ShouldDropLoot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxDynamicDropsComponent", "ShouldDropLoot");

	Params::PhxDynamicDropsComponent_ShouldDropLoot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxEconomyUIInterface.CancelPress
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::CancelPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "CancelPress");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.ClearItems
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::ClearItems()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "ClearItems");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.ConfirmHold
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxEconomyUIInterface::ConfirmHold(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "ConfirmHold");

	Params::PhxEconomyUIInterface_ConfirmHold Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.ConfirmPress
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::ConfirmPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "ConfirmPress");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.ConfirmRelease
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::ConfirmRelease()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "ConfirmRelease");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.DirectionInput
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxEconomyUIInterface::DirectionInput(EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "DirectionInput");

	Params::PhxEconomyUIInterface_DirectionInput Parms{};

	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.FaceLeftHold
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxEconomyUIInterface::FaceLeftHold(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "FaceLeftHold");

	Params::PhxEconomyUIInterface_FaceLeftHold Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.FaceLeftPress
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::FaceLeftPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "FaceLeftPress");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.FaceLeftRelease
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::FaceLeftRelease()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "FaceLeftRelease");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.FaceTopHold
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxEconomyUIInterface::FaceTopHold(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "FaceTopHold");

	Params::PhxEconomyUIInterface_FaceTopHold Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.FaceTopPress
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::FaceTopPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "FaceTopPress");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.FaceTopRelease
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::FaceTopRelease()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "FaceTopRelease");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.Hide
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::Hide()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "Hide");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.R3Press
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::R3Press()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "R3Press");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.Refresh
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::Refresh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "Refresh");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.SetItems
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::SetItems()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "SetItems");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.SetParentInterfaceObject
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UObject*                          Parent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxEconomyUIInterface::SetParentInterfaceObject(class UObject* Parent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "SetParentInterfaceObject");

	Params::PhxEconomyUIInterface_SetParentInterfaceObject Parms{};

	Parms.Parent = Parent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.ShoulderLeftPress
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::ShoulderLeftPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "ShoulderLeftPress");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.ShoulderRightPress
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::ShoulderRightPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "ShoulderRightPress");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.Show
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void IPhxEconomyUIInterface::Show()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "Show");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEconomyUIInterface.GetDeepestUI
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* IPhxEconomyUIInterface::GetDeepestUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "GetDeepestUI");

	Params::PhxEconomyUIInterface_GetDeepestUI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxEconomyUIInterface.IsTopLevel
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IPhxEconomyUIInterface::IsTopLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxEconomyUIInterface", "IsTopLevel");

	Params::PhxEconomyUIInterface_IsTopLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxEnemyGRPHitResponseComponent.OnEnterGRPState
// (Event, Public, BlueprintEvent)

void UPhxEnemyGRPHitResponseComponent::OnEnterGRPState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxEnemyGRPHitResponseComponent", "OnEnterGRPState");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxEnemyGRPHitResponseComponent.OnExitGRPState
// (Event, Public, BlueprintEvent)

void UPhxEnemyGRPHitResponseComponent::OnExitGRPState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxEnemyGRPHitResponseComponent", "OnExitGRPState");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxHasEntitlementArray.HasEntitlements
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const TArray<EPhxEntitlement>&          InEntitlements                                         (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UPhxHasEntitlementArray*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxHasEntitlementArray* UPhxHasEntitlementArray::HasEntitlements(const TArray<EPhxEntitlement>& InEntitlements)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxHasEntitlementArray", "HasEntitlements");

	Params::PhxHasEntitlementArray_HasEntitlements Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxHasEntitlementArray.HandleFetchEntitlements
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxEntitlementOwnership&  Ownership                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxHasEntitlementArray::HandleFetchEntitlements(const struct FPhxEntitlementOwnership& Ownership)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasEntitlementArray", "HandleFetchEntitlements");

	Params::PhxHasEntitlementArray_HandleFetchEntitlements Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxHasEntitlementArray.HandleFetchOnlineAccount
// (Final, Native, Protected)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USDSOnlineAccount*          OnlineAccount                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxHasEntitlementArray::HandleFetchOnlineAccount(bool bSuccess, const class USDSOnlineAccount* OnlineAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxHasEntitlementArray", "HandleFetchOnlineAccount");

	Params::PhxHasEntitlementArray_HandleFetchOnlineAccount Parms{};

	Parms.bSuccess = bSuccess;
	Parms.OnlineAccount = OnlineAccount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxEnvironmentalGoreComponent.OnBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxEnvironmentalGoreComponent::OnBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxEnvironmentalGoreComponent", "OnBeginOverlap");

	Params::PhxEnvironmentalGoreComponent_OnBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TraversalAbilityState.OnTraversalAbilityEnded
// (Final, Native, Protected)
// Parameters:
// const struct FGameplayTag&              InTag                                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTraversalAbilityState::OnTraversalAbilityEnded(const struct FGameplayTag& InTag, int32 NewCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TraversalAbilityState", "OnTraversalAbilityEnded");

	Params::TraversalAbilityState_OnTraversalAbilityEnded Parms{};

	Parms.InTag = std::move(InTag);
	Parms.NewCount = NewCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFlashlight.OnFlashlightColorUpdated
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FLinearColor&              NewColor                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxFlashlight::OnFlashlightColorUpdated(const struct FLinearColor& NewColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlight", "OnFlashlightColorUpdated");

	Params::PhxFlashlight_OnFlashlightColorUpdated Parms{};

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

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


// Function Phoenix.PhxFlashlight.OnVFXConeAlphaUpdated
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   NewAlpha                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   NewEmissiveMultiplier                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxFlashlight::OnVFXConeAlphaUpdated(float NewAlpha, float NewEmissiveMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlight", "OnVFXConeAlphaUpdated");

	Params::PhxFlashlight_OnVFXConeAlphaUpdated Parms{};

	Parms.NewAlpha = NewAlpha;
	Parms.NewEmissiveMultiplier = NewEmissiveMultiplier;

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


// Function Phoenix.PhxFlashlight.OnVolumetricOnlyLightPropertiesUpdated
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   NewRelativeLocation                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  NewRelativeRotation                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   VolumetricScatteringIntensity                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxFlashlight::OnVolumetricOnlyLightPropertiesUpdated(const struct FVector& NewRelativeLocation, const struct FRotator& NewRelativeRotation, float VolumetricScatteringIntensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlight", "OnVolumetricOnlyLightPropertiesUpdated");

	Params::PhxFlashlight_OnVolumetricOnlyLightPropertiesUpdated Parms{};

	Parms.NewRelativeLocation = std::move(NewRelativeLocation);
	Parms.NewRelativeRotation = std::move(NewRelativeRotation);
	Parms.VolumetricScatteringIntensity = VolumetricScatteringIntensity;

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


// Function Phoenix.PhxFlashlightComponent.OnFlashlightBatteryDrained
// (Final, Native, Public)

void UPhxFlashlightComponent::OnFlashlightBatteryDrained()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "OnFlashlightBatteryDrained");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFlashlightComponent.PopCinematicFlashlightStates
// (Final, Native, Public)

void UPhxFlashlightComponent::PopCinematicFlashlightStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "PopCinematicFlashlightStates");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFlashlightComponent.PopDynamicGlobalModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxFlashlightModifier*           Modifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxFlashlightComponent::PopDynamicGlobalModifier(class UPhxFlashlightModifier* Modifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "PopDynamicGlobalModifier");

	Params::PhxFlashlightComponent_PopDynamicGlobalModifier Parms{};

	Parms.Modifier = Modifier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFlashlightComponent.PushDynamicGlobalModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPhxFlashlightModifier*           Modifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxFlashlightComponent::PushDynamicGlobalModifier(class UPhxFlashlightModifier* Modifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "PushDynamicGlobalModifier");

	Params::PhxFlashlightComponent_PushDynamicGlobalModifier Parms{};

	Parms.Modifier = Modifier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFlashlightComponent.PushDynamicGlobalModifierOfClass
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UPhxFlashlightModifier>ModifierClass                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxFlashlightModifier*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxFlashlightModifier* UPhxFlashlightComponent::PushDynamicGlobalModifierOfClass(TSubclassOf<class UPhxFlashlightModifier> ModifierClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "PushDynamicGlobalModifierOfClass");

	Params::PhxFlashlightComponent_PushDynamicGlobalModifierOfClass Parms{};

	Parms.ModifierClass = ModifierClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxFlashlightComponent.ReloadBattery
// (Final, Native, Public, BlueprintCallable)

void UPhxFlashlightComponent::ReloadBattery()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "ReloadBattery");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxFlashlightComponent.GetBatteryModifier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxFlashlightModifier_Battery*   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxFlashlightModifier_Battery* UPhxFlashlightComponent::GetBatteryModifier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "GetBatteryModifier");

	Params::PhxFlashlightComponent_GetBatteryModifier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxFlashlightComponent.IsBatteryFullyDrained
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxFlashlightComponent::IsBatteryFullyDrained() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxFlashlightComponent", "IsBatteryFullyDrained");

	Params::PhxFlashlightComponent_IsBatteryFullyDrained Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameInstance.DestroyLeaveOnlineGame
// (Final, Native, Public, BlueprintCallable)

void UPhxGameInstance::DestroyLeaveOnlineGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameInstance", "DestroyLeaveOnlineGame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameInstance.GetCurrentServerName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UPhxGameInstance::GetCurrentServerName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameInstance", "GetCurrentServerName");

	Params::PhxGameInstance_GetCurrentServerName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameInstance.GetSnowDeformEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameInstance::GetSnowDeformEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameInstance", "GetSnowDeformEnabled");

	Params::PhxGameInstance_GetSnowDeformEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameInstance.SetSnowDeformEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameInstance::SetSnowDeformEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameInstance", "SetSnowDeformEnabled");

	Params::PhxGameInstance_SetSnowDeformEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameInstance.StartDialogue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDialogue*                        InDialogue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           NPCActor                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameInstance::StartDialogue(class UDialogue* InDialogue, class AActor* NPCActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameInstance", "StartDialogue");

	Params::PhxGameInstance_StartDialogue Parms{};

	Parms.InDialogue = InDialogue;
	Parms.NPCActor = NPCActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameInstance.StartSession
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SessionName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameInstance::StartSession(const class FString& SessionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameInstance", "StartSession");

	Params::PhxGameInstance_StartSession Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameInstance.GetBloodSpatterTraceManager
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxBloodSpatterTraceManager*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxBloodSpatterTraceManager* UPhxGameInstance::GetBloodSpatterTraceManager() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameInstance", "GetBloodSpatterTraceManager");

	Params::PhxGameInstance_GetBloodSpatterTraceManager Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameplayAbility_ButtonHoldInteraction.OnDelayTimePassed
// (Final, Native, Protected)

void UPhxGameplayAbility_ButtonHoldInteraction::OnDelayTimePassed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_ButtonHoldInteraction", "OnDelayTimePassed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_ButtonHoldInteraction.OnInteractButtonHeld
// (Final, Native, Protected)
// Parameters:
// float                                   TimeActive                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_ButtonHoldInteraction::OnInteractButtonHeld(float TimeActive, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_ButtonHoldInteraction", "OnInteractButtonHeld");

	Params::PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonHeld Parms{};

	Parms.TimeActive = TimeActive;
	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_ButtonHoldInteraction.OnInteractButtonReleased
// (Final, Native, Protected)
// Parameters:
// float                                   TimeActive                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_ButtonHoldInteraction::OnInteractButtonReleased(float TimeActive, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_ButtonHoldInteraction", "OnInteractButtonReleased");

	Params::PhxGameplayAbility_ButtonHoldInteraction_OnInteractButtonReleased Parms{};

	Parms.TimeActive = TimeActive;
	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnNotifyStateBegin
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_CorpseStomp::OnNotifyStateBegin(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_CorpseStomp", "OnNotifyStateBegin");

	Params::PhxGameplayAbility_CorpseStomp_OnNotifyStateBegin Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnNotifyStateEnd
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotifyState*        NotifyState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_CorpseStomp::OnNotifyStateEnd(const class UPhxAnimNotifyState* NotifyState, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_CorpseStomp", "OnNotifyStateEnd");

	Params::PhxGameplayAbility_CorpseStomp_OnNotifyStateEnd Parms{};

	Parms.NotifyState = NotifyState;
	Parms.Animation = Animation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnStompMontageEnded
// (Final, Native, Protected)

void UPhxGameplayAbility_CorpseStomp::OnStompMontageEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_CorpseStomp", "OnStompMontageEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnStompMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_CorpseStomp::OnStompMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_CorpseStomp", "OnStompMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnStompTraceHit
// (Final, Native, Protected)
// Parameters:
// const TArray<struct FHitResult>&        Hits                                                   (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_CorpseStomp::OnStompTraceHit(const TArray<struct FHitResult>& Hits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_CorpseStomp", "OnStompTraceHit");

	Params::PhxGameplayAbility_CorpseStomp_OnStompTraceHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_CorpseStomp.OnTransitionMontageEnded
// (Final, Native, Protected)

void UPhxGameplayAbility_CorpseStomp::OnTransitionMontageEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_CorpseStomp", "OnTransitionMontageEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_DoScriptedEventStaging.OnCharacterReachedSyncPoint
// (Final, Native, Protected)

void UPhxGameplayAbility_DoScriptedEventStaging::OnCharacterReachedSyncPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_DoScriptedEventStaging", "OnCharacterReachedSyncPoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_DoScriptedEventStaging.OnCharacterUnequippedWeapon
// (Final, Native, Protected)

void UPhxGameplayAbility_DoScriptedEventStaging::OnCharacterUnequippedWeapon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_DoScriptedEventStaging", "OnCharacterUnequippedWeapon");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_EchoScan.OnScanStopped
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    CaughtCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ScanDuration                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_EchoScan::OnScanStopped(class APhxCharacter* CaughtCharacter, float ScanDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_EchoScan", "OnScanStopped");

	Params::PhxGameplayAbility_EchoScan_OnScanStopped Parms{};

	Parms.CaughtCharacter = CaughtCharacter;
	Parms.ScanDuration = ScanDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_FallToFloor.OnCharacterDeath
// (Final, Native, Private)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_FallToFloor::OnCharacterDeath(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_FallToFloor", "OnCharacterDeath");

	Params::PhxGameplayAbility_FallToFloor_OnCharacterDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_FallToFloor.OnLandingEnded
// (Final, Native, Private)

void UPhxGameplayAbility_FallToFloor::OnLandingEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_FallToFloor", "OnLandingEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_FallToFloor.OnMovementModeChanged
// (Final, Native, Private)
// Parameters:
// EMovementMode                           NewMovementMode                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_FallToFloor::OnMovementModeChanged(EMovementMode NewMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_FallToFloor", "OnMovementModeChanged");

	Params::PhxGameplayAbility_FallToFloor_OnMovementModeChanged Parms{};

	Parms.NewMovementMode = NewMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyPull.OnMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_GRPEnemyPull::OnMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyPull", "OnMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyPull.OnMoveTaskFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_GRPEnemyPull::OnMoveTaskFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyPull", "OnMoveTaskFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyRecover.OnEnemyHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyRecover", "OnEnemyHit");

	Params::PhxGameplayAbility_GRPEnemyRecover_OnEnemyHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyRecover.OnMovementModeChanged
// (Final, Native, Protected)
// Parameters:
// EMovementMode                           NewMovementMode                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_GRPEnemyRecover::OnMovementModeChanged(EMovementMode NewMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyRecover", "OnMovementModeChanged");

	Params::PhxGameplayAbility_GRPEnemyRecover_OnMovementModeChanged Parms{};

	Parms.NewMovementMode = NewMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_GRPEnemyRecover.OnMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_GRPEnemyRecover::OnMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_GRPEnemyRecover", "OnMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Pickup.OnUncrouchWaitDelayFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_Pickup::OnUncrouchWaitDelayFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Pickup", "OnUncrouchWaitDelayFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyLift.OnEndMontageFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyLift::OnEndMontageFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyLift", "OnEndMontageFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyLift.OnEnemyHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyLift", "OnEnemyHit");

	Params::PhxGameplayAbility_PPEEnemyLift_OnEnemyHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyLift.OnHitIntoSurfaceMontageFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyLift::OnHitIntoSurfaceMontageFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyLift", "OnHitIntoSurfaceMontageFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyLift.OnPPEMoveOvershootTaskFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyLift::OnPPEMoveOvershootTaskFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyLift", "OnPPEMoveOvershootTaskFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyLift.OnPPEMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyLift::OnPPEMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyLift", "OnPPEMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyLift.OnPPEMoveTaskFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyLift::OnPPEMoveTaskFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyLift", "OnPPEMoveTaskFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPull.OnEnemyHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPull", "OnEnemyHit");

	Params::PhxGameplayAbility_PPEEnemyPull_OnEnemyHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPull.OnFinalMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPull::OnFinalMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPull", "OnFinalMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPull.OnPPEMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPull::OnPPEMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPull", "OnPPEMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPull.OnPPEMoveTaskFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPull::OnPPEMoveTaskFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPull", "OnPPEMoveTaskFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPull.OnTriggerEndAnim
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPull::OnTriggerEndAnim()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPull", "OnTriggerEndAnim");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPush.OnEnemyHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPush", "OnEnemyHit");

	Params::PhxGameplayAbility_PPEEnemyPush_OnEnemyHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPush.OnFinalMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPush::OnFinalMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPush", "OnFinalMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPush.OnHitIntoSurfaceMontageFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPush::OnHitIntoSurfaceMontageFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPush", "OnHitIntoSurfaceMontageFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPush.OnPPEMoveTaskFailed
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPush::OnPPEMoveTaskFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPush", "OnPPEMoveTaskFailed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPush.OnPPEMoveTaskFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPush::OnPPEMoveTaskFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPush", "OnPPEMoveTaskFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PPEEnemyPush.OnTriggerEndAnim
// (Final, Native, Protected)

void UPhxGameplayAbility_PPEEnemyPush::OnTriggerEndAnim()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PPEEnemyPush", "OnTriggerEndAnim");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PuzzleSwitchInteraction.OnCharacterHealthModified
// (Final, Native, Protected)
// Parameters:
// class UPhxHealthComponent*              HealthComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_PuzzleSwitchInteraction::OnCharacterHealthModified(class UPhxHealthComponent* HealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PuzzleSwitchInteraction", "OnCharacterHealthModified");

	Params::PhxGameplayAbility_PuzzleSwitchInteraction_OnCharacterHealthModified Parms{};

	Parms.HealthComp = HealthComp;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_PuzzleSwitchInteraction.OnDelayTimePassed
// (Final, Native, Protected)

void UPhxGameplayAbility_PuzzleSwitchInteraction::OnDelayTimePassed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_PuzzleSwitchInteraction", "OnDelayTimePassed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Reload.OnDefensiveActionInitiated
// (Final, Native, Protected, HasOutParams)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Reload::OnDefensiveActionInitiated(EReactionType ReactionType, EDefensiveReactDirection ReactionDir, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Reload", "OnDefensiveActionInitiated");

	Params::PhxGameplayAbility_Reload_OnDefensiveActionInitiated Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Reload.OnMontageBlendOut
// (Final, Native, Protected)

void UPhxGameplayAbility_Reload::OnMontageBlendOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Reload", "OnMontageBlendOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Reload.OnMontageCancelled
// (Final, Native, Protected)

void UPhxGameplayAbility_Reload::OnMontageCancelled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Reload", "OnMontageCancelled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Reload.OnMontageComplete
// (Final, Native, Protected)

void UPhxGameplayAbility_Reload::OnMontageComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Reload", "OnMontageComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Reload.OnMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_Reload::OnMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Reload", "OnMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Reload.OnNotifyReceived
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Reload::OnNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Reload", "OnNotifyReceived");

	Params::PhxGameplayAbility_Reload_OnNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Stunned.OnDamageTaken
// (Final, Native, Private)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_Stunned::OnDamageTaken(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Stunned", "OnDamageTaken");

	Params::PhxGameplayAbility_Stunned_OnDamageTaken Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Stunned.OnMontageCompleted
// (Final, Native, Private)

void UPhxGameplayAbility_Stunned::OnMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Stunned", "OnMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Stunned.OnWaitCompleted
// (Final, Native, Private)

void UPhxGameplayAbility_Stunned::OnWaitCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Stunned", "OnWaitCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnAttachMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_SwapWeaponReceiver::OnAttachMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnAttachMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnAttachMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_SwapWeaponReceiver::OnAttachMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnAttachMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnDefensiveActionInitiated
// (Final, Native, Protected, HasOutParams)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_SwapWeaponReceiver::OnDefensiveActionInitiated(EReactionType ReactionType, EDefensiveReactDirection ReactionDir, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnDefensiveActionInitiated");

	Params::PhxGameplayAbility_SwapWeaponReceiver_OnDefensiveActionInitiated Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnDetachMontageCompleted
// (Final, Native, Protected)

void UPhxGameplayAbility_SwapWeaponReceiver::OnDetachMontageCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnDetachMontageCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnDetachMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_SwapWeaponReceiver::OnDetachMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnDetachMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnEquipCorrectWeaponFinished
// (Final, Native, Protected)

void UPhxGameplayAbility_SwapWeaponReceiver::OnEquipCorrectWeaponFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnEquipCorrectWeaponFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnNotifyReceived
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_SwapWeaponReceiver::OnNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnNotifyReceived");

	Params::PhxGameplayAbility_SwapWeaponReceiver_OnNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_SwapWeaponReceiver.OnReceiverSwapCanceled
// (Final, Native, Protected)

void UPhxGameplayAbility_SwapWeaponReceiver::OnReceiverSwapCanceled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_SwapWeaponReceiver", "OnReceiverSwapCanceled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_NavPowerJump.OnNavPowerJumpComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_NavPowerJump::OnNavPowerJumpComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_NavPowerJump", "OnNavPowerJumpComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_NavPowerJump.OnNavPowerJumpFail
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_NavPowerJump::OnNavPowerJumpFail()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_NavPowerJump", "OnNavPowerJumpFail");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Stationary.OnMontageCancelledEvent
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Stationary::OnMontageCancelledEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Stationary", "OnMontageCancelledEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Stationary.OnMontageCompletedEvent
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Stationary::OnMontageCompletedEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Stationary", "OnMontageCompletedEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Stationary.OnPreMoveComplete
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Stationary::OnPreMoveComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Stationary", "OnPreMoveComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_Traverse_Teleport.OnDelayFinished
// (Final, Native, Private)

void UPhxGameplayAbility_Traverse_Teleport::OnDelayFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_Traverse_Teleport", "OnDelayFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UnequipWeapon.OnMontageBlendOut
// (Final, Native, Protected)

void UPhxGameplayAbility_UnequipWeapon::OnMontageBlendOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UnequipWeapon", "OnMontageBlendOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UnequipWeapon.OnMontageCancelled
// (Final, Native, Protected)

void UPhxGameplayAbility_UnequipWeapon::OnMontageCancelled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UnequipWeapon", "OnMontageCancelled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UnequipWeapon.OnMontageComplete
// (Final, Native, Protected)

void UPhxGameplayAbility_UnequipWeapon::OnMontageComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UnequipWeapon", "OnMontageComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UnequipWeapon.OnMontageInterrupted
// (Final, Native, Protected)

void UPhxGameplayAbility_UnequipWeapon::OnMontageInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UnequipWeapon", "OnMontageInterrupted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameplayAbility_UnequipWeapon.OnNotifyReceived
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameplayAbility_UnequipWeapon::OnNotifyReceived(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameplayAbility_UnequipWeapon", "OnNotifyReceived");

	Params::PhxGameplayAbility_UnequipWeapon_OnNotifyReceived Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSRiotStoreIcon.HideIcon
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AWSRiotStoreIcon::HideIcon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSRiotStoreIcon", "HideIcon");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSRiotStoreIcon.ShowIcon
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AWSRiotStoreIcon::ShowIcon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSRiotStoreIcon", "ShowIcon");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.AvailableScreenResolutions
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const bool                              bWindowed                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FIntPoint>          ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FIntPoint> UPhxGameUserSettings::AvailableScreenResolutions(const bool bWindowed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameUserSettings", "AvailableScreenResolutions");

	Params::PhxGameUserSettings_AvailableScreenResolutions Parms{};

	Parms.bWindowed = bWindowed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UPhxGameUserSettings*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxGameUserSettings* UPhxGameUserSettings::Get()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameUserSettings", "Get");

	Params::PhxGameUserSettings_Get Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAvailablePeakNits
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const TArray<float>                     ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<float> UPhxGameUserSettings::GetAvailablePeakNits()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxGameUserSettings", "GetAvailablePeakNits");

	Params::PhxGameUserSettings_GetAvailablePeakNits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.AccumulateRiotCreditsSpent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::AccumulateRiotCreditsSpent(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "AccumulateRiotCreditsSpent");

	Params::PhxGameUserSettings_AccumulateRiotCreditsSpent Parms{};

	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.AddHighscore
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPhxHighScoreRecord&       InScore                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::AddHighscore(const struct FPhxHighScoreRecord& InScore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "AddHighscore");

	Params::PhxGameUserSettings_AddHighscore Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.AddUnlockedRiotModePerk
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxRiotModePerkType                    Perk                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::AddUnlockedRiotModePerk(EPhxRiotModePerkType Perk)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "AddUnlockedRiotModePerk");

	Params::PhxGameUserSettings_AddUnlockedRiotModePerk Parms{};

	Parms.Perk = Perk;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.ApplyHDR
// (Final, Native, Public, BlueprintCallable)

void UPhxGameUserSettings::ApplyHDR()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "ApplyHDR");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.ClearHighscores
// (Final, Native, Public, BlueprintCallable)

void UPhxGameUserSettings::ClearHighscores()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "ClearHighscores");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.ClearKeymappingList
// (Final, Native, Public, BlueprintCallable)

void UPhxGameUserSettings::ClearKeymappingList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "ClearKeymappingList");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.ClearRiotCreditsSpent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::ClearRiotCreditsSpent(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "ClearRiotCreditsSpent");

	Params::PhxGameUserSettings_ClearRiotCreditsSpent Parms{};

	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.ClearRiotPowerupActivationCount
// (Final, Native, Public, BlueprintCallable)

void UPhxGameUserSettings::ClearRiotPowerupActivationCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "ClearRiotPowerupActivationCount");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.ClearSettingsGameplayTags
// (Final, Native, Public, BlueprintCallable)

void UPhxGameUserSettings::ClearSettingsGameplayTags()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "ClearSettingsGameplayTags");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.ClearUnlockedRiotModePerks
// (Final, Native, Public, BlueprintCallable)

void UPhxGameUserSettings::ClearUnlockedRiotModePerks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "ClearUnlockedRiotModePerks");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.EnableConsolePerformanceMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::EnableConsolePerformanceMode(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "EnableConsolePerformanceMode");

	Params::PhxGameUserSettings_EnableConsolePerformanceMode Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.IncrementRiotPowerupActivationCount
// (Final, Native, Public, BlueprintCallable)

void UPhxGameUserSettings::IncrementRiotPowerupActivationCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IncrementRiotPowerupActivationCount");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.PromptForDialogCultureChangeIfNecessary
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    CultureCode                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnConfirm                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnCancel                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::PromptForDialogCultureChangeIfNecessary(const class FString& CultureCode, const TDelegate<void()>& OnConfirm, const TDelegate<void()>& OnCancel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "PromptForDialogCultureChangeIfNecessary");

	Params::PhxGameUserSettings_PromptForDialogCultureChangeIfNecessary Parms{};

	Parms.CultureCode = std::move(CultureCode);
	Parms.OnConfirm = OnConfirm;
	Parms.OnCancel = OnCancel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.PushActivatedTutorialTag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TutorialTag                                            (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::PushActivatedTutorialTag(const struct FGameplayTag& TutorialTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "PushActivatedTutorialTag");

	Params::PhxGameUserSettings_PushActivatedTutorialTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetAimAssistEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetAimAssistEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetAimAssistEnabled");

	Params::PhxGameUserSettings_SetAimAssistEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetAimAssistStrength
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Strenth                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetAimAssistStrength(int32 Strenth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetAimAssistStrength");

	Params::PhxGameUserSettings_SetAimAssistStrength Parms{};

	Parms.Strenth = Strenth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetAimParallaxEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetAimParallaxEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetAimParallaxEnabled");

	Params::PhxGameUserSettings_SetAimParallaxEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetAimSensitivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Sensitivity                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetAimSensitivity(float Sensitivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetAimSensitivity");

	Params::PhxGameUserSettings_SetAimSensitivity Parms{};

	Parms.Sensitivity = Sensitivity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetAntiAliasingMethod
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EAntiAliasingMethod               InAntiAliasingMethod                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetAntiAliasingMethod(const EAntiAliasingMethod InAntiAliasingMethod)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetAntiAliasingMethod");

	Params::PhxGameUserSettings_SetAntiAliasingMethod Parms{};

	Parms.InAntiAliasingMethod = InAntiAliasingMethod;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetAutoAimEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetAutoAimEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetAutoAimEnabled");

	Params::PhxGameUserSettings_SetAutoAimEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetAutoDodgeEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetAutoDodgeEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetAutoDodgeEnabled");

	Params::PhxGameUserSettings_SetAutoDodgeEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetBenchmarkMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetBenchmarkMode(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetBenchmarkMode");

	Params::PhxGameUserSettings_SetBenchmarkMode Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetBlackPointValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetBlackPointValue(float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetBlackPointValue");

	Params::PhxGameUserSettings_SetBlackPointValue Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetButtonHoldAssistEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetButtonHoldAssistEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetButtonHoldAssistEnabled");

	Params::PhxGameUserSettings_SetButtonHoldAssistEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetButtonPromptSize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESDSSize                                Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetButtonPromptSize(ESDSSize Size)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetButtonPromptSize");

	Params::PhxGameUserSettings_SetButtonPromptSize Parms{};

	Parms.Size = Size;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetCameraShakeIntensity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetCameraShakeIntensity(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetCameraShakeIntensity");

	Params::PhxGameUserSettings_SetCameraShakeIntensity Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetCameraShakeReduceEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bReduce                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetCameraShakeReduceEnabled(bool bReduce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetCameraShakeReduceEnabled");

	Params::PhxGameUserSettings_SetCameraShakeReduceEnabled Parms{};

	Parms.bReduce = bReduce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetCameraTwistIntensity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetCameraTwistIntensity(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetCameraTwistIntensity");

	Params::PhxGameUserSettings_SetCameraTwistIntensity Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetCameraTwistReduceEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bReduce                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetCameraTwistReduceEnabled(bool bReduce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetCameraTwistReduceEnabled");

	Params::PhxGameUserSettings_SetCameraTwistReduceEnabled Parms{};

	Parms.bReduce = bReduce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetControllerSensitivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Sensitivity                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetControllerSensitivity(float Sensitivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetControllerSensitivity");

	Params::PhxGameUserSettings_SetControllerSensitivity Parms{};

	Parms.Sensitivity = Sensitivity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDepthOfFieldEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInDepthOfFieldEnabled                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDepthOfFieldEnabled(const bool bInDepthOfFieldEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDepthOfFieldEnabled");

	Params::PhxGameUserSettings_SetDepthOfFieldEnabled Parms{};

	Parms.bInDepthOfFieldEnabled = bInDepthOfFieldEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDialogCulture
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    CultureCode                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnFailure                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bAllowLanguagePackDownload                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSetByUser                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDialogCulture(const class FString& CultureCode, const TDelegate<void()>& OnFailure, bool bAllowLanguagePackDownload, bool bSetByUser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDialogCulture");

	Params::PhxGameUserSettings_SetDialogCulture Parms{};

	Parms.CultureCode = std::move(CultureCode);
	Parms.OnFailure = OnFailure;
	Parms.bAllowLanguagePackDownload = bAllowLanguagePackDownload;
	Parms.bSetByUser = bSetByUser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDialogueEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDialogueEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDialogueEnabled");

	Params::PhxGameUserSettings_SetDialogueEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDialogueVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDialogueVolume(float Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDialogueVolume");

	Params::PhxGameUserSettings_SetDialogueVolume Parms{};

	Parms.Volume = Volume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDirectXRHI
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EDirectXRHI                       InDirectXRHI                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDirectXRHI(const EDirectXRHI InDirectXRHI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDirectXRHI");

	Params::PhxGameUserSettings_SetDirectXRHI Parms{};

	Parms.InDirectXRHI = InDirectXRHI;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDismembermentUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDismembermentUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDismembermentUnlockDisplayed");

	Params::PhxGameUserSettings_SetDismembermentUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDisplayType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxDisplayType                         InDisplayType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDisplayType(EPhxDisplayType InDisplayType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDisplayType");

	Params::PhxGameUserSettings_SetDisplayType Parms{};

	Parms.InDisplayType = InDisplayType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDLCNotificationIcon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsOn                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDLCNotificationIcon(bool bIsOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDLCNotificationIcon");

	Params::PhxGameUserSettings_SetDLCNotificationIcon Parms{};

	Parms.bIsOn = bIsOn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDLCStoreUnlockID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   VersionID                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDLCStoreUnlockID(int32 VersionID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDLCStoreUnlockID");

	Params::PhxGameUserSettings_SetDLCStoreUnlockID Parms{};

	Parms.VersionID = VersionID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetDyslexicFontEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetDyslexicFontEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetDyslexicFontEnabled");

	Params::PhxGameUserSettings_SetDyslexicFontEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetFilmGrainEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInFilmGrainEnabled                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetFilmGrainEnabled(const bool bInFilmGrainEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetFilmGrainEnabled");

	Params::PhxGameUserSettings_SetFilmGrainEnabled Parms{};

	Parms.bInFilmGrainEnabled = bInFilmGrainEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetFirstOnlineRun
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInFirstOnlineRun                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetFirstOnlineRun(bool bInFirstOnlineRun)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetFirstOnlineRun");

	Params::PhxGameUserSettings_SetFirstOnlineRun Parms{};

	Parms.bInFirstOnlineRun = bInFirstOnlineRun;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetFirstRun
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInFirstRun                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetFirstRun(bool bInFirstRun)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetFirstRun");

	Params::PhxGameUserSettings_SetFirstRun Parms{};

	Parms.bInFirstRun = bInFirstRun;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetFSR2Mode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EFSR2QualityModeWrapper           bInFSR2Mode                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetFSR2Mode(const EFSR2QualityModeWrapper bInFSR2Mode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetFSR2Mode");

	Params::PhxGameUserSettings_SetFSR2Mode Parms{};

	Parms.bInFSR2Mode = bInFSR2Mode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetGameDifficultyLevel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxDifficultyLevel                     Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetGameDifficultyLevel(EPhxDifficultyLevel Level)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetGameDifficultyLevel");

	Params::PhxGameUserSettings_SetGameDifficultyLevel Parms{};

	Parms.Level = Level;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetGoldSkinUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetGoldSkinUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetGoldSkinUnlockDisplayed");

	Params::PhxGameUserSettings_SetGoldSkinUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetGoreEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetGoreEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetGoreEnabled");

	Params::PhxGameUserSettings_SetGoreEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetGraphicsPreset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxGraphicsPreset                      PresetLevel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetGraphicsPreset(EPhxGraphicsPreset PresetLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetGraphicsPreset");

	Params::PhxGameUserSettings_SetGraphicsPreset Parms{};

	Parms.PresetLevel = PresetLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetGyroAimEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetGyroAimEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetGyroAimEnabled");

	Params::PhxGameUserSettings_SetGyroAimEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetGyroAimSensitivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Sensitivity                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetGyroAimSensitivity(float Sensitivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetGyroAimSensitivity");

	Params::PhxGameUserSettings_SetGyroAimSensitivity Parms{};

	Parms.Sensitivity = Sensitivity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHallucinationFXEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHallucinationFXEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHallucinationFXEnabled");

	Params::PhxGameUserSettings_SetHallucinationFXEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHardcoreNGPlusUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHardcoreNGPlusUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHardcoreNGPlusUnlockDisplayed");

	Params::PhxGameUserSettings_SetHardcoreNGPlusUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHardcoreUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHardcoreUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHardcoreUnlockDisplayed");

	Params::PhxGameUserSettings_SetHardcoreUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHasShownNewGamePlusNotification
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewHasShownNewGamePlusNotification                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHasShownNewGamePlusNotification(bool bNewHasShownNewGamePlusNotification)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHasShownNewGamePlusNotification");

	Params::PhxGameUserSettings_SetHasShownNewGamePlusNotification Parms{};

	Parms.bNewHasShownNewGamePlusNotification = bNewHasShownNewGamePlusNotification;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHazmatUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHazmatUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHazmatUnlockDisplayed");

	Params::PhxGameUserSettings_SetHazmatUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHCEnemyColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InColor                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHCEnemyColor(const struct FLinearColor& InColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHCEnemyColor");

	Params::PhxGameUserSettings_SetHCEnemyColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHCHazardColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InColor                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHCHazardColor(const struct FLinearColor& InColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHCHazardColor");

	Params::PhxGameUserSettings_SetHCHazardColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHCPickupColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InColor                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHCPickupColor(const struct FLinearColor& InColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHCPickupColor");

	Params::PhxGameUserSettings_SetHCPickupColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHCPlayerColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InColor                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHCPlayerColor(const struct FLinearColor& InColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHCPlayerColor");

	Params::PhxGameUserSettings_SetHCPlayerColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHDRBlackPointCorrectionValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHDRBlackPointCorrectionValue(float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHDRBlackPointCorrectionValue");

	Params::PhxGameUserSettings_SetHDRBlackPointCorrectionValue Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHDRBrightnessValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHDRBrightnessValue(float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHDRBrightnessValue");

	Params::PhxGameUserSettings_SetHDRBrightnessValue Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHideBrightnessFlow
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bHide                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHideBrightnessFlow(bool bHide)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHideBrightnessFlow");

	Params::PhxGameUserSettings_SetHideBrightnessFlow Parms{};

	Parms.bHide = bHide;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHighContrastEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHighContrastEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHighContrastEnabled");

	Params::PhxGameUserSettings_SetHighContrastEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetHordeUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetHordeUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetHordeUnlockDisplayed");

	Params::PhxGameUserSettings_SetHordeUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetInputMappingSettings
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSoftObjectPtr<class UPhxInputMappingSettings>&InputMappingSettingsAsset                              (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetInputMappingSettings(const TSoftObjectPtr<class UPhxInputMappingSettings>& InputMappingSettingsAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetInputMappingSettings");

	Params::PhxGameUserSettings_SetInputMappingSettings Parms{};

	Parms.InputMappingSettingsAsset = InputMappingSettingsAsset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetInventoryParallaxEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetInventoryParallaxEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetInventoryParallaxEnabled");

	Params::PhxGameUserSettings_SetInventoryParallaxEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetInvertMouseX
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInvert                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetInvertMouseX(bool bInvert)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetInvertMouseX");

	Params::PhxGameUserSettings_SetInvertMouseX Parms{};

	Parms.bInvert = bInvert;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetInvertMouseY
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInvert                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetInvertMouseY(bool bInvert)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetInvertMouseY");

	Params::PhxGameUserSettings_SetInvertMouseY Parms{};

	Parms.bInvert = bInvert;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetInvertX
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInvert                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetInvertX(bool bInvert)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetInvertX");

	Params::PhxGameUserSettings_SetInvertX Parms{};

	Parms.bInvert = bInvert;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetInvertY
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInvert                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetInvertY(bool bInvert)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetInvertY");

	Params::PhxGameUserSettings_SetInvertY Parms{};

	Parms.bInvert = bInvert;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetKeyMapping
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<struct FPhxInputActionMappingSetting>&ActionList                                             (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const TArray<struct FPhxInputAxisMappingSetting>&AxisList                                               (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetKeyMapping(const TArray<struct FPhxInputActionMappingSetting>& ActionList, const TArray<struct FPhxInputAxisMappingSetting>& AxisList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetKeyMapping");

	Params::PhxGameUserSettings_SetKeyMapping Parms{};

	Parms.ActionList = std::move(ActionList);
	Parms.AxisList = std::move(AxisList);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetLefthandBiasedInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUseLeftBiasedInput                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetLefthandBiasedInput(bool bUseLeftBiasedInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetLefthandBiasedInput");

	Params::PhxGameUserSettings_SetLefthandBiasedInput Parms{};

	Parms.bUseLeftBiasedInput = bUseLeftBiasedInput;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetLightingQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InLightingQuality                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetLightingQuality(const EGraphicsQuality InLightingQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetLightingQuality");

	Params::PhxGameUserSettings_SetLightingQuality Parms{};

	Parms.InLightingQuality = InLightingQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetLookSensitivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Sensitivity                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetLookSensitivity(float Sensitivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetLookSensitivity");

	Params::PhxGameUserSettings_SetLookSensitivity Parms{};

	Parms.Sensitivity = Sensitivity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetLowHealthFXEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetLowHealthFXEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetLowHealthFXEnabled");

	Params::PhxGameUserSettings_SetLowHealthFXEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMeleeHoldEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMeleeHoldEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMeleeHoldEnabled");

	Params::PhxGameUserSettings_SetMeleeHoldEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMenuReaderEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMenuReaderEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMenuReaderEnabled");

	Params::PhxGameUserSettings_SetMenuReaderEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMeshQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InMeshQuality                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMeshQuality(const EGraphicsQuality InMeshQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMeshQuality");

	Params::PhxGameUserSettings_SetMeshQuality Parms{};

	Parms.InMeshQuality = InMeshQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMotionBlurEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInMotionBlurEnabled                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMotionBlurEnabled(const bool bInMotionBlurEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMotionBlurEnabled");

	Params::PhxGameUserSettings_SetMotionBlurEnabled Parms{};

	Parms.bInMotionBlurEnabled = bInMotionBlurEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMouseAimSensitivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Sensitivity                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMouseAimSensitivity(float Sensitivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMouseAimSensitivity");

	Params::PhxGameUserSettings_SetMouseAimSensitivity Parms{};

	Parms.Sensitivity = Sensitivity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMouseAimSmoothing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMouseAimSmoothing(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMouseAimSmoothing");

	Params::PhxGameUserSettings_SetMouseAimSmoothing Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMouseLookSensitivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Sensitivity                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMouseLookSensitivity(float Sensitivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMouseLookSensitivity");

	Params::PhxGameUserSettings_SetMouseLookSensitivity Parms{};

	Parms.Sensitivity = Sensitivity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMouseLookSmoothing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMouseLookSmoothing(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMouseLookSmoothing");

	Params::PhxGameUserSettings_SetMouseLookSmoothing Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMusicEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMusicEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMusicEnabled");

	Params::PhxGameUserSettings_SetMusicEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetMusicVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetMusicVolume(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetMusicVolume");

	Params::PhxGameUserSettings_SetMusicVolume Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetParticleQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InParticleQuality                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetParticleQuality(const EGraphicsQuality InParticleQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetParticleQuality");

	Params::PhxGameUserSettings_SetParticleQuality Parms{};

	Parms.InParticleQuality = InParticleQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetPhysicalRefractionEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInPhysicalRefractionEnabled                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetPhysicalRefractionEnabled(const bool bInPhysicalRefractionEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetPhysicalRefractionEnabled");

	Params::PhxGameUserSettings_SetPhysicalRefractionEnabled Parms{};

	Parms.bInPhysicalRefractionEnabled = bInPhysicalRefractionEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetQTEAutoCompleteEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetQTEAutoCompleteEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetQTEAutoCompleteEnabled");

	Params::PhxGameUserSettings_SetQTEAutoCompleteEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetQTESinglePressEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetQTESinglePressEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetQTESinglePressEnabled");

	Params::PhxGameUserSettings_SetQTESinglePressEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetRadioBanterChannel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxRadioBanterChannel                  Channel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetRadioBanterChannel(EPhxRadioBanterChannel Channel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetRadioBanterChannel");

	Params::PhxGameUserSettings_SetRadioBanterChannel Parms{};

	Parms.Channel = Channel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetRadioBanterVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetRadioBanterVolume(float Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetRadioBanterVolume");

	Params::PhxGameUserSettings_SetRadioBanterVolume Parms{};

	Parms.Volume = Volume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetRaytracedReflectionsQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InRaytracedReflectionsQuality                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetRaytracedReflectionsQuality(const EGraphicsQuality InRaytracedReflectionsQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetRaytracedReflectionsQuality");

	Params::PhxGameUserSettings_SetRaytracedReflectionsQuality Parms{};

	Parms.InRaytracedReflectionsQuality = InRaytracedReflectionsQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetRaytracedShadowsEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInRaytracedShadowsEnabled                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetRaytracedShadowsEnabled(const bool bInRaytracedShadowsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetRaytracedShadowsEnabled");

	Params::PhxGameUserSettings_SetRaytracedShadowsEnabled Parms{};

	Parms.bInRaytracedShadowsEnabled = bInRaytracedShadowsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetRaytracedTransmissionEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInRaytracedTransmissionEnabled                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetRaytracedTransmissionEnabled(const bool bInRaytracedTransmissionEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetRaytracedTransmissionEnabled");

	Params::PhxGameUserSettings_SetRaytracedTransmissionEnabled Parms{};

	Parms.bInRaytracedTransmissionEnabled = bInRaytracedTransmissionEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetRenderResolutionPercentage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             InRenderResolutionPercentage                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetRenderResolutionPercentage(const float InRenderResolutionPercentage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetRenderResolutionPercentage");

	Params::PhxGameUserSettings_SetRenderResolutionPercentage Parms{};

	Parms.InRenderResolutionPercentage = InRenderResolutionPercentage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetRumbleEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetRumbleEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetRumbleEnabled");

	Params::PhxGameUserSettings_SetRumbleEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetScreenSpaceReflectionsEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInScreenSpaceReflectionsEnabled                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetScreenSpaceReflectionsEnabled(const bool bInScreenSpaceReflectionsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetScreenSpaceReflectionsEnabled");

	Params::PhxGameUserSettings_SetScreenSpaceReflectionsEnabled Parms{};

	Parms.bInScreenSpaceReflectionsEnabled = bInScreenSpaceReflectionsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSeenMenuReaderPrompt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bSeenPrompt                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSeenMenuReaderPrompt(bool bSeenPrompt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSeenMenuReaderPrompt");

	Params::PhxGameUserSettings_SetSeenMenuReaderPrompt Parms{};

	Parms.bSeenPrompt = bSeenPrompt;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSFXEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSFXEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSFXEnabled");

	Params::PhxGameUserSettings_SetSFXEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSFXVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSFXVolume(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSFXVolume");

	Params::PhxGameUserSettings_SetSFXVolume Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetShadowMapQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InShadowMapQuality                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetShadowMapQuality(const EGraphicsQuality InShadowMapQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetShadowMapQuality");

	Params::PhxGameUserSettings_SetShadowMapQuality Parms{};

	Parms.InShadowMapQuality = InShadowMapQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetShowRiotModeRules
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShowRules                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetShowRiotModeRules(bool bShowRules)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetShowRiotModeRules");

	Params::PhxGameUserSettings_SetShowRiotModeRules Parms{};

	Parms.bShowRules = bShowRules;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetStoryDLCUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetStoryDLCUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetStoryDLCUnlockDisplayed");

	Params::PhxGameUserSettings_SetStoryDLCUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsBGColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InValue                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsBGColor(const struct FLinearColor& InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsBGColor");

	Params::PhxGameUserSettings_SetSubsBGColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsBGEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsBGEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsBGEnabled");

	Params::PhxGameUserSettings_SetSubsBGEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsBGOpacity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsBGOpacity(float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsBGOpacity");

	Params::PhxGameUserSettings_SetSubsBGOpacity Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsCulture
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    CultureCode                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSetByUser                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsCulture(const class FString& CultureCode, bool bSetByUser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsCulture");

	Params::PhxGameUserSettings_SetSubsCulture Parms{};

	Parms.CultureCode = std::move(CultureCode);
	Parms.bSetByUser = bSetByUser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsEnabled");

	Params::PhxGameUserSettings_SetSubsEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsFontColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InValue                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsFontColor(const struct FLinearColor& InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsFontColor");

	Params::PhxGameUserSettings_SetSubsFontColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsFontScale
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsFontScale(float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsFontScale");

	Params::PhxGameUserSettings_SetSubsFontScale Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsSpeakerColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InValue                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsSpeakerColor(const struct FLinearColor& InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsSpeakerColor");

	Params::PhxGameUserSettings_SetSubsSpeakerColor Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsSpeakerEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsSpeakerEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsSpeakerEnabled");

	Params::PhxGameUserSettings_SetSubsSpeakerEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSubsurfaceScatteringEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInSubsurfaceScatteringEnabled                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSubsurfaceScatteringEnabled(const bool bInSubsurfaceScatteringEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSubsurfaceScatteringEnabled");

	Params::PhxGameUserSettings_SetSubsurfaceScatteringEnabled Parms{};

	Parms.bInSubsurfaceScatteringEnabled = bInSubsurfaceScatteringEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSurvivalNGPlusUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSurvivalNGPlusUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSurvivalNGPlusUnlockDisplayed");

	Params::PhxGameUserSettings_SetSurvivalNGPlusUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetSurvivalUnlockDisplayed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsDisplayed                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetSurvivalUnlockDisplayed(bool bInIsDisplayed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetSurvivalUnlockDisplayed");

	Params::PhxGameUserSettings_SetSurvivalUnlockDisplayed Parms{};

	Parms.bInIsDisplayed = bInIsDisplayed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetTextCulture
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    CultureCode                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSetByUser                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetTextCulture(const class FString& CultureCode, bool bSetByUser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetTextCulture");

	Params::PhxGameUserSettings_SetTextCulture Parms{};

	Parms.CultureCode = std::move(CultureCode);
	Parms.bSetByUser = bSetByUser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetTextureFilterQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InTextureFilterQuality                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetTextureFilterQuality(const EGraphicsQuality InTextureFilterQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetTextureFilterQuality");

	Params::PhxGameUserSettings_SetTextureFilterQuality Parms{};

	Parms.InTextureFilterQuality = InTextureFilterQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetTextureResolutionQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InTextureResolutionQuality                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetTextureResolutionQuality(const EGraphicsQuality InTextureResolutionQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetTextureResolutionQuality");

	Params::PhxGameUserSettings_SetTextureResolutionQuality Parms{};

	Parms.InTextureResolutionQuality = InTextureResolutionQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetUpscalingMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EUpscalingMode                    bInUpscalingMode                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetUpscalingMode(const EUpscalingMode bInUpscalingMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetUpscalingMode");

	Params::PhxGameUserSettings_SetUpscalingMode Parms{};

	Parms.bInUpscalingMode = bInUpscalingMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetUserScreenResolution
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const EWindowMode                       InWindowMode                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FIntPoint&                 InResolution                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetUserScreenResolution(const EWindowMode InWindowMode, const struct FIntPoint& InResolution)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetUserScreenResolution");

	Params::PhxGameUserSettings_SetUserScreenResolution Parms{};

	Parms.InWindowMode = InWindowMode;
	Parms.InResolution = std::move(InResolution);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetVolumetricsQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EGraphicsQuality                  InVolumetricsQuality                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetVolumetricsQuality(const EGraphicsQuality InVolumetricsQuality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetVolumetricsQuality");

	Params::PhxGameUserSettings_SetVolumetricsQuality Parms{};

	Parms.InVolumetricsQuality = InVolumetricsQuality;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetWantedHDROutput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInWantedHDROutput                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetWantedHDROutput(const bool bInWantedHDROutput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetWantedHDROutput");

	Params::PhxGameUserSettings_SetWantedHDROutput Parms{};

	Parms.bInWantedHDROutput = bInWantedHDROutput;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.SetWantedPeakNits
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             InWantedPeakNits                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxGameUserSettings::SetWantedPeakNits(const float InWantedPeakNits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SetWantedPeakNits");

	Params::PhxGameUserSettings_SetWantedPeakNits Parms{};

	Parms.InWantedPeakNits = InWantedPeakNits;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGameUserSettings.AvailableDialogLanguages
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TMap<class FString, class FText>  ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TMap<class FString, class FText> UPhxGameUserSettings::AvailableDialogLanguages() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "AvailableDialogLanguages");

	Params::PhxGameUserSettings_AvailableDialogLanguages Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetActionKeyMappingList
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FPhxInputActionMappingSetting>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FPhxInputActionMappingSetting> UPhxGameUserSettings::GetActionKeyMappingList() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetActionKeyMappingList");

	Params::PhxGameUserSettings_GetActionKeyMappingList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAimAssistEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetAimAssistEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAimAssistEnabled");

	Params::PhxGameUserSettings_GetAimAssistEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAimAssistStrength
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxGameUserSettings::GetAimAssistStrength() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAimAssistStrength");

	Params::PhxGameUserSettings_GetAimAssistStrength Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAimParallaxEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetAimParallaxEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAimParallaxEnabled");

	Params::PhxGameUserSettings_GetAimParallaxEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAimSensitivity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetAimSensitivity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAimSensitivity");

	Params::PhxGameUserSettings_GetAimSensitivity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAntiAliasingMethod
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAntiAliasingMethod                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAntiAliasingMethod UPhxGameUserSettings::GetAntiAliasingMethod() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAntiAliasingMethod");

	Params::PhxGameUserSettings_GetAntiAliasingMethod Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAutoAimEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetAutoAimEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAutoAimEnabled");

	Params::PhxGameUserSettings_GetAutoAimEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAutoDodgeEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetAutoDodgeEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAutoDodgeEnabled");

	Params::PhxGameUserSettings_GetAutoDodgeEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetAxisKeyMappingList
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FPhxInputAxisMappingSetting>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FPhxInputAxisMappingSetting> UPhxGameUserSettings::GetAxisKeyMappingList() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetAxisKeyMappingList");

	Params::PhxGameUserSettings_GetAxisKeyMappingList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetBenchmarkMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetBenchmarkMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetBenchmarkMode");

	Params::PhxGameUserSettings_GetBenchmarkMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetBlackPointValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetBlackPointValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetBlackPointValue");

	Params::PhxGameUserSettings_GetBlackPointValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetButtonHoldAssistEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetButtonHoldAssistEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetButtonHoldAssistEnabled");

	Params::PhxGameUserSettings_GetButtonHoldAssistEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetButtonPromptSize
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ESDSSize                                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESDSSize UPhxGameUserSettings::GetButtonPromptSize() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetButtonPromptSize");

	Params::PhxGameUserSettings_GetButtonPromptSize Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetCameraShakeIntensity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetCameraShakeIntensity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetCameraShakeIntensity");

	Params::PhxGameUserSettings_GetCameraShakeIntensity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetCameraTwistIntensity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetCameraTwistIntensity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetCameraTwistIntensity");

	Params::PhxGameUserSettings_GetCameraTwistIntensity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetControllerSensitivity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetControllerSensitivity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetControllerSensitivity");

	Params::PhxGameUserSettings_GetControllerSensitivity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDialogCulture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxGameUserSettings::GetDialogCulture() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDialogCulture");

	Params::PhxGameUserSettings_GetDialogCulture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDialogueVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetDialogueVolume() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDialogueVolume");

	Params::PhxGameUserSettings_GetDialogueVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDifficultyLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxDifficultyLevel                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxDifficultyLevel UPhxGameUserSettings::GetDifficultyLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDifficultyLevel");

	Params::PhxGameUserSettings_GetDifficultyLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDirectXRHI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EDirectXRHI                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EDirectXRHI UPhxGameUserSettings::GetDirectXRHI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDirectXRHI");

	Params::PhxGameUserSettings_GetDirectXRHI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDirectXRHIInUse
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EDirectXRHI                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EDirectXRHI UPhxGameUserSettings::GetDirectXRHIInUse() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDirectXRHIInUse");

	Params::PhxGameUserSettings_GetDirectXRHIInUse Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDisplayType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxDisplayType                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxDisplayType UPhxGameUserSettings::GetDisplayType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDisplayType");

	Params::PhxGameUserSettings_GetDisplayType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDLCNotificationIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetDLCNotificationIcon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDLCNotificationIcon");

	Params::PhxGameUserSettings_GetDLCNotificationIcon Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetDyslexicFontEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetDyslexicFontEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetDyslexicFontEnabled");

	Params::PhxGameUserSettings_GetDyslexicFontEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetFSR2Mode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFSR2QualityModeWrapper                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFSR2QualityModeWrapper UPhxGameUserSettings::GetFSR2Mode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetFSR2Mode");

	Params::PhxGameUserSettings_GetFSR2Mode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetGoreEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetGoreEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetGoreEnabled");

	Params::PhxGameUserSettings_GetGoreEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetGyroAimEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetGyroAimEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetGyroAimEnabled");

	Params::PhxGameUserSettings_GetGyroAimEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetGyroAimSensitivity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetGyroAimSensitivity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetGyroAimSensitivity");

	Params::PhxGameUserSettings_GetGyroAimSensitivity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHallucinationFXEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetHallucinationFXEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHallucinationFXEnabled");

	Params::PhxGameUserSettings_GetHallucinationFXEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHasShownNewGamePlusNotification
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetHasShownNewGamePlusNotification() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHasShownNewGamePlusNotification");

	Params::PhxGameUserSettings_GetHasShownNewGamePlusNotification Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHCEnemyColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FLinearColor               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FLinearColor UPhxGameUserSettings::GetHCEnemyColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHCEnemyColor");

	Params::PhxGameUserSettings_GetHCEnemyColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHCHazardColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FLinearColor               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FLinearColor UPhxGameUserSettings::GetHCHazardColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHCHazardColor");

	Params::PhxGameUserSettings_GetHCHazardColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHCPickupColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FLinearColor               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FLinearColor UPhxGameUserSettings::GetHCPickupColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHCPickupColor");

	Params::PhxGameUserSettings_GetHCPickupColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHCPlayerColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FLinearColor               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FLinearColor UPhxGameUserSettings::GetHCPlayerColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHCPlayerColor");

	Params::PhxGameUserSettings_GetHCPlayerColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHDRBlackPointCorrection
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetHDRBlackPointCorrection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHDRBlackPointCorrection");

	Params::PhxGameUserSettings_GetHDRBlackPointCorrection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHDRBrightness
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetHDRBrightness() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHDRBrightness");

	Params::PhxGameUserSettings_GetHDRBrightness Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHDRSupportStatus
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EHDRSupportStatus                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EHDRSupportStatus UPhxGameUserSettings::GetHDRSupportStatus() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHDRSupportStatus");

	Params::PhxGameUserSettings_GetHDRSupportStatus Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHideBrightnessFlow
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetHideBrightnessFlow() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHideBrightnessFlow");

	Params::PhxGameUserSettings_GetHideBrightnessFlow Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHighContrastEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetHighContrastEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHighContrastEnabled");

	Params::PhxGameUserSettings_GetHighContrastEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHighScoreList
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FPhxHighScoreRecord>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FPhxHighScoreRecord> UPhxGameUserSettings::GetHighScoreList() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHighScoreList");

	Params::PhxGameUserSettings_GetHighScoreList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetHighScoreListSize
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxGameUserSettings::GetHighScoreListSize() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetHighScoreListSize");

	Params::PhxGameUserSettings_GetHighScoreListSize Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetInputMappingSettings
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftObjectPtr<class UPhxInputMappingSettings>ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const TSoftObjectPtr<class UPhxInputMappingSettings> UPhxGameUserSettings::GetInputMappingSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetInputMappingSettings");

	Params::PhxGameUserSettings_GetInputMappingSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetInventoryParallaxEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetInventoryParallaxEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetInventoryParallaxEnabled");

	Params::PhxGameUserSettings_GetInventoryParallaxEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetInvertMouseX
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetInvertMouseX() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetInvertMouseX");

	Params::PhxGameUserSettings_GetInvertMouseX Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetInvertMouseY
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetInvertMouseY() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetInvertMouseY");

	Params::PhxGameUserSettings_GetInvertMouseY Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetInvertX
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetInvertX() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetInvertX");

	Params::PhxGameUserSettings_GetInvertX Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetInvertY
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetInvertY() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetInvertY");

	Params::PhxGameUserSettings_GetInvertY Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetLastDLCStoreUnlockID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxGameUserSettings::GetLastDLCStoreUnlockID() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetLastDLCStoreUnlockID");

	Params::PhxGameUserSettings_GetLastDLCStoreUnlockID Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetLastScoreIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxGameUserSettings::GetLastScoreIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetLastScoreIndex");

	Params::PhxGameUserSettings_GetLastScoreIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetLightingQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetLightingQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetLightingQuality");

	Params::PhxGameUserSettings_GetLightingQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetLookSensitivity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetLookSensitivity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetLookSensitivity");

	Params::PhxGameUserSettings_GetLookSensitivity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetLowHealthFXEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetLowHealthFXEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetLowHealthFXEnabled");

	Params::PhxGameUserSettings_GetLowHealthFXEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMeleeHoldEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetMeleeHoldEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMeleeHoldEnabled");

	Params::PhxGameUserSettings_GetMeleeHoldEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMenuReaderEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetMenuReaderEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMenuReaderEnabled");

	Params::PhxGameUserSettings_GetMenuReaderEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMeshQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetMeshQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMeshQuality");

	Params::PhxGameUserSettings_GetMeshQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMouseAimSensitivity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetMouseAimSensitivity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMouseAimSensitivity");

	Params::PhxGameUserSettings_GetMouseAimSensitivity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMouseAimSmoothingEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetMouseAimSmoothingEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMouseAimSmoothingEnabled");

	Params::PhxGameUserSettings_GetMouseAimSmoothingEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMouseLookSensitivity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetMouseLookSensitivity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMouseLookSensitivity");

	Params::PhxGameUserSettings_GetMouseLookSensitivity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMouseLookSmoothingEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetMouseLookSmoothingEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMouseLookSmoothingEnabled");

	Params::PhxGameUserSettings_GetMouseLookSmoothingEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetMusicVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetMusicVolume() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetMusicVolume");

	Params::PhxGameUserSettings_GetMusicVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetParticleQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetParticleQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetParticleQuality");

	Params::PhxGameUserSettings_GetParticleQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetPlayerSkinIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxGameUserSettings::GetPlayerSkinIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetPlayerSkinIndex");

	Params::PhxGameUserSettings_GetPlayerSkinIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetQTEAutoCompleteEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetQTEAutoCompleteEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetQTEAutoCompleteEnabled");

	Params::PhxGameUserSettings_GetQTEAutoCompleteEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetQTESinglePressEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetQTESinglePressEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetQTESinglePressEnabled");

	Params::PhxGameUserSettings_GetQTESinglePressEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetRadioBanterChannel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxRadioBanterChannel                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxRadioBanterChannel UPhxGameUserSettings::GetRadioBanterChannel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetRadioBanterChannel");

	Params::PhxGameUserSettings_GetRadioBanterChannel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetRadioBanterVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetRadioBanterVolume() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetRadioBanterVolume");

	Params::PhxGameUserSettings_GetRadioBanterVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetRaytracedReflectionsQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetRaytracedReflectionsQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetRaytracedReflectionsQuality");

	Params::PhxGameUserSettings_GetRaytracedReflectionsQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetRenderResolutionPercentage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetRenderResolutionPercentage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetRenderResolutionPercentage");

	Params::PhxGameUserSettings_GetRenderResolutionPercentage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetRiotModeCreditsSpent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxGameUserSettings::GetRiotModeCreditsSpent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetRiotModeCreditsSpent");

	Params::PhxGameUserSettings_GetRiotModeCreditsSpent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetRiotPowerupActivationCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxGameUserSettings::GetRiotPowerupActivationCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetRiotPowerupActivationCount");

	Params::PhxGameUserSettings_GetRiotPowerupActivationCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSFXVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetSFXVolume() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSFXVolume");

	Params::PhxGameUserSettings_GetSFXVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetShadowMapQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetShadowMapQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetShadowMapQuality");

	Params::PhxGameUserSettings_GetShadowMapQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetShowRiotModeRules
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetShowRiotModeRules() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetShowRiotModeRules");

	Params::PhxGameUserSettings_GetShowRiotModeRules Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsBGColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FLinearColor               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FLinearColor UPhxGameUserSettings::GetSubsBGColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsBGColor");

	Params::PhxGameUserSettings_GetSubsBGColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsBGEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetSubsBGEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsBGEnabled");

	Params::PhxGameUserSettings_GetSubsBGEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsBGOpacity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetSubsBGOpacity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsBGOpacity");

	Params::PhxGameUserSettings_GetSubsBGOpacity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsCulture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxGameUserSettings::GetSubsCulture() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsCulture");

	Params::PhxGameUserSettings_GetSubsCulture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetSubsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsEnabled");

	Params::PhxGameUserSettings_GetSubsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsFontColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FLinearColor               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FLinearColor UPhxGameUserSettings::GetSubsFontColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsFontColor");

	Params::PhxGameUserSettings_GetSubsFontColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsFontScale
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetSubsFontScale() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsFontScale");

	Params::PhxGameUserSettings_GetSubsFontScale Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsSpeakerColor
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          OutHex                                                 (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FLinearColor UPhxGameUserSettings::GetSubsSpeakerColor(class FString* OutHex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsSpeakerColor");

	Params::PhxGameUserSettings_GetSubsSpeakerColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetSubsSpeakerEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetSubsSpeakerEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetSubsSpeakerEnabled");

	Params::PhxGameUserSettings_GetSubsSpeakerEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetTextCulture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxGameUserSettings::GetTextCulture() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetTextCulture");

	Params::PhxGameUserSettings_GetTextCulture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetTextureFilterQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetTextureFilterQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetTextureFilterQuality");

	Params::PhxGameUserSettings_GetTextureFilterQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetTextureResolutionQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetTextureResolutionQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetTextureResolutionQuality");

	Params::PhxGameUserSettings_GetTextureResolutionQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetUnlockedRiotModePerks
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<EPhxRiotModePerkType>      ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<EPhxRiotModePerkType> UPhxGameUserSettings::GetUnlockedRiotModePerks() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetUnlockedRiotModePerks");

	Params::PhxGameUserSettings_GetUnlockedRiotModePerks Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetUpscalingMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EUpscalingMode                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EUpscalingMode UPhxGameUserSettings::GetUpscalingMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetUpscalingMode");

	Params::PhxGameUserSettings_GetUpscalingMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetUserScreenResolution
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EWindowMode                       InWindowMode                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FIntPoint                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FIntPoint UPhxGameUserSettings::GetUserScreenResolution(const EWindowMode InWindowMode) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetUserScreenResolution");

	Params::PhxGameUserSettings_GetUserScreenResolution Parms{};

	Parms.InWindowMode = InWindowMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetVolumetricsQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGraphicsQuality                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGraphicsQuality UPhxGameUserSettings::GetVolumetricsQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetVolumetricsQuality");

	Params::PhxGameUserSettings_GetVolumetricsQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetWantedHDROutput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::GetWantedHDROutput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetWantedHDROutput");

	Params::PhxGameUserSettings_GetWantedHDROutput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.GetWantedPeakNits
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGameUserSettings::GetWantedPeakNits() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "GetWantedPeakNits");

	Params::PhxGameUserSettings_GetWantedPeakNits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsCameraShakeReduced
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsCameraShakeReduced() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsCameraShakeReduced");

	Params::PhxGameUserSettings_IsCameraShakeReduced Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsCameraTwistReduced
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsCameraTwistReduced() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsCameraTwistReduced");

	Params::PhxGameUserSettings_IsCameraTwistReduced Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsConsolePerformanceModeEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsConsolePerformanceModeEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsConsolePerformanceModeEnabled");

	Params::PhxGameUserSettings_IsConsolePerformanceModeEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsDepthOfFieldEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsDepthOfFieldEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsDepthOfFieldEnabled");

	Params::PhxGameUserSettings_IsDepthOfFieldEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsDialogueEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsDialogueEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsDialogueEnabled");

	Params::PhxGameUserSettings_IsDialogueEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsFilmGrainEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsFilmGrainEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsFilmGrainEnabled");

	Params::PhxGameUserSettings_IsFilmGrainEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsFirstOnlineRun
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsFirstOnlineRun() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsFirstOnlineRun");

	Params::PhxGameUserSettings_IsFirstOnlineRun Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsFirstRun
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsFirstRun() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsFirstRun");

	Params::PhxGameUserSettings_IsFirstRun Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsGraphicsPreset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxGraphicsPreset                      PresetLevel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsGraphicsPreset(EPhxGraphicsPreset PresetLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsGraphicsPreset");

	Params::PhxGameUserSettings_IsGraphicsPreset Parms{};

	Parms.PresetLevel = PresetLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsLeftHandBiasedController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsLeftHandBiasedController() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsLeftHandBiasedController");

	Params::PhxGameUserSettings_IsLeftHandBiasedController Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsMotionBlurEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsMotionBlurEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsMotionBlurEnabled");

	Params::PhxGameUserSettings_IsMotionBlurEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsMusicEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsMusicEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsMusicEnabled");

	Params::PhxGameUserSettings_IsMusicEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsPhysicalRefractionEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsPhysicalRefractionEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsPhysicalRefractionEnabled");

	Params::PhxGameUserSettings_IsPhysicalRefractionEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsRadioBanterChannelSupported
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsRadioBanterChannelSupported() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsRadioBanterChannelSupported");

	Params::PhxGameUserSettings_IsRadioBanterChannelSupported Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsRaytracedShadowsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsRaytracedShadowsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsRaytracedShadowsEnabled");

	Params::PhxGameUserSettings_IsRaytracedShadowsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsRaytracedTransmissionEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsRaytracedTransmissionEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsRaytracedTransmissionEnabled");

	Params::PhxGameUserSettings_IsRaytracedTransmissionEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsRumbleEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsRumbleEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsRumbleEnabled");

	Params::PhxGameUserSettings_IsRumbleEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsScreenSpaceReflectionsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsScreenSpaceReflectionsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsScreenSpaceReflectionsEnabled");

	Params::PhxGameUserSettings_IsScreenSpaceReflectionsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsSFXEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsSFXEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsSFXEnabled");

	Params::PhxGameUserSettings_IsSFXEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsSubsurfaceScatteringEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsSubsurfaceScatteringEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsSubsurfaceScatteringEnabled");

	Params::PhxGameUserSettings_IsSubsurfaceScatteringEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsTutorialTagActivated
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              TutorialTag                                            (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsTutorialTagActivated(const struct FGameplayTag& TutorialTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsTutorialTagActivated");

	Params::PhxGameUserSettings_IsTutorialTagActivated Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.IsUsingHDR
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::IsUsingHDR() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "IsUsingHDR");

	Params::PhxGameUserSettings_IsUsingHDR Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.LocalizationContentManagerSupportsInGameInstall
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::LocalizationContentManagerSupportsInGameInstall() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "LocalizationContentManagerSupportsInGameInstall");

	Params::PhxGameUserSettings_LocalizationContentManagerSupportsInGameInstall Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.LocalizationContentManagerUsesEpicGamesStore
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::LocalizationContentManagerUsesEpicGamesStore() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "LocalizationContentManagerUsesEpicGamesStore");

	Params::PhxGameUserSettings_LocalizationContentManagerUsesEpicGamesStore Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.LocalizationContentManagerUsesSteam
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::LocalizationContentManagerUsesSteam() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "LocalizationContentManagerUsesSteam");

	Params::PhxGameUserSettings_LocalizationContentManagerUsesSteam Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.SeenMenuReaderPrompt
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::SeenMenuReaderPrompt() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SeenMenuReaderPrompt");

	Params::PhxGameUserSettings_SeenMenuReaderPrompt Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.SupportsConsolePerformanceMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::SupportsConsolePerformanceMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "SupportsConsolePerformanceMode");

	Params::PhxGameUserSettings_SupportsConsolePerformanceMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasDismembermentUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasDismembermentUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasDismembermentUnlockDisplayed");

	Params::PhxGameUserSettings_WasDismembermentUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasGoldSkinUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasGoldSkinUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasGoldSkinUnlockDisplayed");

	Params::PhxGameUserSettings_WasGoldSkinUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasHardcoreNGPlusUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasHardcoreNGPlusUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasHardcoreNGPlusUnlockDisplayed");

	Params::PhxGameUserSettings_WasHardcoreNGPlusUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasHardcoreUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasHardcoreUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasHardcoreUnlockDisplayed");

	Params::PhxGameUserSettings_WasHardcoreUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasHazmatUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasHazmatUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasHazmatUnlockDisplayed");

	Params::PhxGameUserSettings_WasHazmatUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasHordeUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasHordeUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasHordeUnlockDisplayed");

	Params::PhxGameUserSettings_WasHordeUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasStoryDLCUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasStoryDLCUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasStoryDLCUnlockDisplayed");

	Params::PhxGameUserSettings_WasStoryDLCUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasSurvivalNGPlusUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasSurvivalNGPlusUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasSurvivalNGPlusUnlockDisplayed");

	Params::PhxGameUserSettings_WasSurvivalNGPlusUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGameUserSettings.WasSurvivalUnlockDisplayed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxGameUserSettings::WasSurvivalUnlockDisplayed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGameUserSettings", "WasSurvivalUnlockDisplayed");

	Params::PhxGameUserSettings_WasSurvivalUnlockDisplayed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSWeaponSwitcher.DisableWeaponSwitcherInput
// (Final, Native, Protected, BlueprintCallable)

void AWSWeaponSwitcher::DisableWeaponSwitcherInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSWeaponSwitcher", "DisableWeaponSwitcherInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSWeaponSwitcher.EnableWeaponSwitcherInput
// (Final, Native, Protected, BlueprintCallable)

void AWSWeaponSwitcher::EnableWeaponSwitcherInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSWeaponSwitcher", "EnableWeaponSwitcherInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGRPInteractionData.GetLaunchSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGRPLaunchLevel                         LaunchLevel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGRPInteractionData::GetLaunchSpeed(EGRPLaunchLevel LaunchLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPInteractionData", "GetLaunchSpeed");

	Params::PhxGRPInteractionData_GetLaunchSpeed Parms{};

	Parms.LaunchLevel = LaunchLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGRPInteractionData.GetPropCollisionDamageValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGRPLaunchLevel                         LaunchLevel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxGRPInteractionData::GetPropCollisionDamageValue(EGRPLaunchLevel LaunchLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPInteractionData", "GetPropCollisionDamageValue");

	Params::PhxGRPInteractionData_GetPropCollisionDamageValue Parms{};

	Parms.LaunchLevel = LaunchLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxGRPPhysicsProp.HandlePropHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "HandlePropHit");

	Params::PhxGRPPhysicsProp_HandlePropHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGRPPhysicsProp.OnEnterHeld
// (Event, Protected, BlueprintEvent)

void APhxGRPPhysicsProp::OnEnterHeld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnEnterHeld");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGRPPhysicsProp.OnEnterLaunched
// (Event, Protected, BlueprintEvent)

void APhxGRPPhysicsProp::OnEnterLaunched()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnEnterLaunched");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGRPPhysicsProp.OnEnterPulled
// (Event, Protected, BlueprintEvent)

void APhxGRPPhysicsProp::OnEnterPulled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnEnterPulled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGRPPhysicsProp.OnExplode
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)

void APhxGRPPhysicsProp::OnExplode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnExplode");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGRPPhysicsProp.OnGRPCollidedDuringHeld
// (Event, Protected, BlueprintEvent)

void APhxGRPPhysicsProp::OnGRPCollidedDuringHeld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnGRPCollidedDuringHeld");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGRPPhysicsProp.OnGRPCollidedDuringLaunched
// (Event, Protected, BlueprintEvent)

void APhxGRPPhysicsProp::OnGRPCollidedDuringLaunched()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnGRPCollidedDuringLaunched");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGRPPhysicsProp.OnGRPCollidedDuringPulled
// (Event, Protected, BlueprintEvent)

void APhxGRPPhysicsProp::OnGRPCollidedDuringPulled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnGRPCollidedDuringPulled");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGRPPhysicsProp.OnGRPOverlappedHitReceiver
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APhxCharacter*                    OverlappedCharacter                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxGRPPhysicsProp::OnGRPOverlappedHitReceiver(class APhxCharacter* OverlappedCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnGRPOverlappedHitReceiver");

	Params::PhxGRPPhysicsProp_OnGRPOverlappedHitReceiver Parms{};

	Parms.OverlappedCharacter = OverlappedCharacter;

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


// Function Phoenix.PhxGRPPhysicsProp.OnGRPRelease
// (Event, Protected, BlueprintEvent)

void APhxGRPPhysicsProp::OnGRPRelease()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnGRPRelease");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxGRPPhysicsProp.OnLootDropBoxDamageTaken
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           InstigatorActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxGRPPhysicsProp::OnLootDropBoxDamageTaken(class AActor* InstigatorActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPPhysicsProp", "OnLootDropBoxDamageTaken");

	Params::PhxGRPPhysicsProp_OnLootDropBoxDamageTaken Parms{};

	Parms.InstigatorActor = InstigatorActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxGRPProxyActor.SetGRPEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInGRPEnabled                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxGRPProxyActor::SetGRPEnabled(bool bInGRPEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxGRPProxyActor", "SetGRPEnabled");

	Params::PhxGRPProxyActor_SetGRPEnabled Parms{};

	Parms.bInGRPEnabled = bInGRPEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWarnIncomingAttackModifier.OnAnyAttackStarted
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    Attacker                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAttackState*                     AttackState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWarnIncomingAttackModifier::OnAnyAttackStarted(class APhxCharacter* Attacker, class UAttackState* AttackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWarnIncomingAttackModifier", "OnAnyAttackStarted");

	Params::PhxWarnIncomingAttackModifier_OnAnyAttackStarted Parms{};

	Parms.Attacker = Attacker;
	Parms.AttackState = AttackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWorldMarker.HandleGamePaused
// (Final, Native, Private)
// Parameters:
// bool                                    bPaused                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxWorldMarker::HandleGamePaused(bool bPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldMarker", "HandleGamePaused");

	Params::PhxWorldMarker_HandleGamePaused Parms{};

	Parms.bPaused = bPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWorldMarker.SetTimeout
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InTimeout                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxWorldMarker::SetTimeout(float InTimeout)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldMarker", "SetTimeout");

	Params::PhxWorldMarker_SetTimeout Parms{};

	Parms.InTimeout = InTimeout;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWorldMarker.GetTargetActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class AActor* APhxWorldMarker::GetTargetActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldMarker", "GetTargetActor");

	Params::PhxWorldMarker_GetTargetActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputKeyToAction.LookupInputKey
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FName&                      ActionName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AxisScale                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxInputKeys                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxInputKeys UPhxInputKeyToAction::LookupInputKey(const class FName& ActionName, float AxisScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputKeyToAction", "LookupInputKey");

	Params::PhxInputKeyToAction_LookupInputKey Parms{};

	Parms.ActionName = ActionName;
	Parms.AxisScale = AxisScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputKeyToAction.RebuildInputIconTable
// (Final, Native, Public)
// Parameters:
// const class APhxPlayerController*       PlayerController                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxInputKeyToAction::RebuildInputIconTable(const class APhxPlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputKeyToAction", "RebuildInputIconTable");

	Params::PhxInputKeyToAction_RebuildInputIconTable Parms{};

	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInputKeyToAction.GetUIInputKeyAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxInputKeys                           InKey                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FActionMapKey              ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FActionMapKey UPhxInputKeyToAction::GetUIInputKeyAction(EPhxInputKeys InKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputKeyToAction", "GetUIInputKeyAction");

	Params::PhxInputKeyToAction_GetUIInputKeyAction Parms{};

	Parms.InKey = InKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputAxisMappingData.GetInputKeyList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InScale                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FKey>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKey> UPhxInputAxisMappingData::GetInputKeyList(EPhxInputType InType, float InScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputAxisMappingData", "GetInputKeyList");

	Params::PhxInputAxisMappingData_GetInputKeyList Parms{};

	Parms.InType = InType;
	Parms.InScale = InScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputAxisMappingData.GetInputKeyForUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InScale                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UPhxInputAxisMappingData::GetInputKeyForUI(EPhxInputType InType, float InScale) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputAxisMappingData", "GetInputKeyForUI");

	Params::PhxInputAxisMappingData_GetInputKeyForUI Parms{};

	Parms.InType = InType;
	Parms.InScale = InScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputAxisMappingData.IsInputType
// (Final, Native, Public, Const)
// Parameters:
// const struct FKey&                      Key                                                    (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxInputAxisMappingData::IsInputType(const struct FKey& Key, EPhxInputType InType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputAxisMappingData", "IsInputType");

	Params::PhxInputAxisMappingData_IsInputType Parms{};

	Parms.Key = std::move(Key);
	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.ClearLeftBiasedInputs
// (Final, Native, Public, BlueprintCallable)

void UPhxInputMappingSettings::ClearLeftBiasedInputs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "ClearLeftBiasedInputs");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInputMappingSettings.GetFilteredMappingForAction
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      ActionName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxInputActionMappingData*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxInputActionMappingData* UPhxInputMappingSettings::GetFilteredMappingForAction(const class FName& ActionName, EPhxInputType InType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetFilteredMappingForAction");

	Params::PhxInputMappingSettings_GetFilteredMappingForAction Parms{};

	Parms.ActionName = ActionName;
	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetFilteredMappingForAxis
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      AxisName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AxisScale                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxInputType                           InType                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxInputAxisMappingData*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxInputAxisMappingData* UPhxInputMappingSettings::GetFilteredMappingForAxis(const class FName& AxisName, float AxisScale, EPhxInputType InType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetFilteredMappingForAxis");

	Params::PhxInputMappingSettings_GetFilteredMappingForAxis Parms{};

	Parms.AxisName = AxisName;
	Parms.AxisScale = AxisScale;
	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetKeyListForAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             InActionName                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InAxisScale                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxInputType                           InFilter                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FKey>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKey> UPhxInputMappingSettings::GetKeyListForAction(class FName InActionName, float InAxisScale, EPhxInputType InFilter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetKeyListForAction");

	Params::PhxInputMappingSettings_GetKeyListForAction Parms{};

	Parms.InActionName = InActionName;
	Parms.InAxisScale = InAxisScale;
	Parms.InFilter = InFilter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetRemappableInputMappingForAction
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      ActionName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxInputActionMappingData*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxInputActionMappingData* UPhxInputMappingSettings::GetRemappableInputMappingForAction(const class FName& ActionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetRemappableInputMappingForAction");

	Params::PhxInputMappingSettings_GetRemappableInputMappingForAction Parms{};

	Parms.ActionName = ActionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetRemappableInputMappingForAxis
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      AxisName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxInputAxisMappingData*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxInputAxisMappingData* UPhxInputMappingSettings::GetRemappableInputMappingForAxis(const class FName& AxisName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetRemappableInputMappingForAxis");

	Params::PhxInputMappingSettings_GetRemappableInputMappingForAxis Parms{};

	Parms.AxisName = AxisName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetUILabelForController
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InScale                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAnalog                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FText>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FText> UPhxInputMappingSettings::GetUILabelForController(const struct FKey& InKey, float InScale, bool bIsAnalog)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetUILabelForController");

	Params::PhxInputMappingSettings_GetUILabelForController Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InScale = InScale;
	Parms.bIsAnalog = bIsAnalog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.SetLeftBiasedInputs
// (Final, Native, Public, BlueprintCallable)

void UPhxInputMappingSettings::SetLeftBiasedInputs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "SetLeftBiasedInputs");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInputMappingSettings.GetActionLabelForUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ActionName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InScale                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAnalog                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UPhxInputMappingSettings::GetActionLabelForUI(class FName ActionName, float InScale, bool bIsAnalog) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetActionLabelForUI");

	Params::PhxInputMappingSettings_GetActionLabelForUI Parms{};

	Parms.ActionName = ActionName;
	Parms.InScale = InScale;
	Parms.bIsAnalog = bIsAnalog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetInputMappingForAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       ActionName                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxInputActionMappingData* ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UPhxInputActionMappingData* UPhxInputMappingSettings::GetInputMappingForAction(const class FName ActionName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetInputMappingForAction");

	Params::PhxInputMappingSettings_GetInputMappingForAction Parms{};

	Parms.ActionName = ActionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetInputMappingForAxis
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       AxisName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxInputAxisMappingData*   ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UPhxInputAxisMappingData* UPhxInputMappingSettings::GetInputMappingForAxis(const class FName AxisName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetInputMappingForAxis");

	Params::PhxInputMappingSettings_GetInputMappingForAxis Parms{};

	Parms.AxisName = AxisName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.GetKeyForAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             InActionName                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InAxisScale                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxInputType                           InFilter                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UPhxInputMappingSettings::GetKeyForAction(class FName InActionName, float InAxisScale, EPhxInputType InFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "GetKeyForAction");

	Params::PhxInputMappingSettings_GetKeyForAction Parms{};

	Parms.InActionName = InActionName;
	Parms.InAxisScale = InAxisScale;
	Parms.InFilter = InFilter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInputMappingSettings.IsKeyMappedForUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxInputMappingSettings::IsKeyMappedForUI(const struct FKey& InKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInputMappingSettings", "IsKeyMappedForUI");

	Params::PhxInputMappingSettings_IsKeyMappedForUI Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxInteractableLootProp.DisableInteractionOnItems
// (Final, Native, Public, BlueprintCallable)

void APhxInteractableLootProp::DisableInteractionOnItems()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInteractableLootProp", "DisableInteractionOnItems");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInteractableLootProp.EnableInteractionOnItems
// (Final, Native, Public, BlueprintCallable)

void APhxInteractableLootProp::EnableInteractionOnItems()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInteractableLootProp", "EnableInteractionOnItems");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInteractableLootProp.OnActorRestored
// (Final, Native, Protected)

void APhxInteractableLootProp::OnActorRestored()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInteractableLootProp", "OnActorRestored");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInteractableLootProp.PlayOpenMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bActorRestored                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxInteractableLootProp::PlayOpenMontage(bool bActorRestored)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInteractableLootProp", "PlayOpenMontage");

	Params::PhxInteractableLootProp_PlayOpenMontage Parms{};

	Parms.bActorRestored = bActorRestored;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxInteractableLootProp.PrepareToPlayOpenMontage
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bActorRestored                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxInteractableLootProp::PrepareToPlayOpenMontage(bool bActorRestored)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInteractableLootProp", "PrepareToPlayOpenMontage");

	Params::PhxInteractableLootProp_PrepareToPlayOpenMontage Parms{};

	Parms.bActorRestored = bActorRestored;

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


// Function Phoenix.PhxInteractableManager.OnButtonPromptSizeChanged
// (Final, Native, Private)
// Parameters:
// ESDSSize                                NewSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxInteractableManager::OnButtonPromptSizeChanged(ESDSSize NewSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxInteractableManager", "OnButtonPromptSizeChanged");

	Params::PhxInteractableManager_OnButtonPromptSizeChanged Parms{};

	Parms.NewSize = NewSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxItemManager.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxItemManager*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxItemManager* UPhxItemManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxItemManager", "Get");

	Params::PhxItemManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxItemManager.GetDefaultItemData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UClass*                           PickupClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FItemData                        ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FItemData UPhxItemManager::GetDefaultItemData(class UClass* PickupClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxItemManager", "GetDefaultItemData");

	Params::PhxItemManager_GetDefaultItemData Parms{};

	Parms.PickupClass = PickupClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxItemManager.GetDefaultItemDataFromHandle
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FDataTableRowHandle&       ItemRowHandle                                          (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FItemData                        ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FItemData UPhxItemManager::GetDefaultItemDataFromHandle(const struct FDataTableRowHandle& ItemRowHandle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxItemManager", "GetDefaultItemDataFromHandle");

	Params::PhxItemManager_GetDefaultItemDataFromHandle Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxItemManager.GetDefaultItemDataFromSoftClass
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftClassPtr<class UClass>&      PickupClass                                            (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FItemData                        ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FItemData UPhxItemManager::GetDefaultItemDataFromSoftClass(const TSoftClassPtr<class UClass>& PickupClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxItemManager", "GetDefaultItemDataFromSoftClass");

	Params::PhxItemManager_GetDefaultItemDataFromSoftClass Parms{};

	Parms.PickupClass = PickupClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxItemManager.GetItemsUnlockedWith
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FItemData&                 Item                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FItemData>*               OutItems                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxItemManager::GetItemsUnlockedWith(const struct FItemData& Item, TArray<struct FItemData>* OutItems) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxItemManager", "GetItemsUnlockedWith");

	Params::PhxItemManager_GetItemsUnlockedWith Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxKeyToControllerKey.GetKeyIcon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxControllerKeys                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxControllerKeys UPhxKeyToControllerKey::GetKeyIcon(const struct FKey& InKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxKeyToControllerKey", "GetKeyIcon");

	Params::PhxKeyToControllerKey_GetKeyIcon Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterManager.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxLevelPacingMeterManager*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxLevelPacingMeterManager* UPhxLevelPacingMeterManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxLevelPacingMeterManager", "Get");

	Params::PhxLevelPacingMeterManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterManager.OnCheckpointReached
// (Final, Native, Protected)
// Parameters:
// class ACheckpoint*                      Checkpoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterManager::OnCheckpointReached(class ACheckpoint* Checkpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "OnCheckpointReached");

	Params::PhxLevelPacingMeterManager_OnCheckpointReached Parms{};

	Parms.Checkpoint = Checkpoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterManager.OnProgressBeginRestore
// (Final, Native, Protected)
// Parameters:
// class ACheckpoint*                      Checkpoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterManager::OnProgressBeginRestore(class ACheckpoint* Checkpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "OnProgressBeginRestore");

	Params::PhxLevelPacingMeterManager_OnProgressBeginRestore Parms{};

	Parms.Checkpoint = Checkpoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterManager.OnProgressRestored
// (Final, Native, Protected)
// Parameters:
// class ACheckpoint*                      Checkpoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterManager::OnProgressRestored(class ACheckpoint* Checkpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "OnProgressRestored");

	Params::PhxLevelPacingMeterManager_OnProgressRestored Parms{};

	Parms.Checkpoint = Checkpoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterManager.SetLevelSpaceActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class APhxLevelPacingMeterSpace>SpacePtr                                               (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsActive                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterManager::SetLevelSpaceActive(TSoftObjectPtr<class APhxLevelPacingMeterSpace> SpacePtr, bool bIsActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "SetLevelSpaceActive");

	Params::PhxLevelPacingMeterManager_SetLevelSpaceActive Parms{};

	Parms.SpacePtr = SpacePtr;
	Parms.bIsActive = bIsActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterManager.SetLevelSpaceActiveByStaticIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   StaticArrayIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsActive                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterManager::SetLevelSpaceActiveByStaticIndex(int32 StaticArrayIndex, bool IsActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "SetLevelSpaceActiveByStaticIndex");

	Params::PhxLevelPacingMeterManager_SetLevelSpaceActiveByStaticIndex Parms{};

	Parms.StaticArrayIndex = StaticArrayIndex;
	Parms.IsActive = IsActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterManager.SetupLevelPacingMeter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class APhxLevelPacingMeterSpace*>&NewLevelPacingSpaces                                   (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxLevelPacingMeterManager::SetupLevelPacingMeter(const TArray<class APhxLevelPacingMeterSpace*>& NewLevelPacingSpaces)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "SetupLevelPacingMeter");

	Params::PhxLevelPacingMeterManager_SetupLevelPacingMeter Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelPacingMeterManager.GetCurrentSpace
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APhxLevelPacingMeterSpace*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxLevelPacingMeterSpace* UPhxLevelPacingMeterManager::GetCurrentSpace() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "GetCurrentSpace");

	Params::PhxLevelPacingMeterManager_GetCurrentSpace Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterManager.GetDynamicSpaces
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class APhxLevelPacingMeterSpace*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class APhxLevelPacingMeterSpace*> UPhxLevelPacingMeterManager::GetDynamicSpaces() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "GetDynamicSpaces");

	Params::PhxLevelPacingMeterManager_GetDynamicSpaces Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterManager.GetNonLevelSpaceTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxLevelPacingMeterManager::GetNonLevelSpaceTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "GetNonLevelSpaceTime");

	Params::PhxLevelPacingMeterManager_GetNonLevelSpaceTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelPacingMeterManager.GetTotalTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxLevelPacingMeterManager::GetTotalTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelPacingMeterManager", "GetTotalTime");

	Params::PhxLevelPacingMeterManager_GetTotalTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelScriptActor.PhxGameReady
// (Event, Public, BlueprintEvent)

void APhxLevelScriptActor::PhxGameReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelScriptActor", "PhxGameReady");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxLevelStreamingManager.IsLevelTranstionDataLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class ULevelTransitionDataAsset*  LevelTransitionData                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxLevelStreamingManager::IsLevelTranstionDataLoaded(const class ULevelTransitionDataAsset* LevelTransitionData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "IsLevelTranstionDataLoaded");

	Params::PhxLevelStreamingManager_IsLevelTranstionDataLoaded Parms{};

	Parms.LevelTransitionData = LevelTransitionData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelStreamingManager.IsPreloadLevelsLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UPreloadLevelsDataAsset*    PreloadLevelsData                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxLevelStreamingManager::IsPreloadLevelsLoaded(const class UPreloadLevelsDataAsset* PreloadLevelsData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "IsPreloadLevelsLoaded");

	Params::PhxLevelStreamingManager_IsPreloadLevelsLoaded Parms{};

	Parms.PreloadLevelsData = PreloadLevelsData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelStreamingManager.OpenLevelFromMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class ULevelTransitionDataAsset*  LevelTransitionData                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelStreamingManager::OpenLevelFromMenu(const class ULevelTransitionDataAsset* LevelTransitionData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "OpenLevelFromMenu");

	Params::PhxLevelStreamingManager_OpenLevelFromMenu Parms{};

	Parms.LevelTransitionData = LevelTransitionData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingManager.PreloadLevels
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UPreloadLevelsDataAsset*    PreloadLevelsData                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelStreamingManager::PreloadLevels(const class UPreloadLevelsDataAsset* PreloadLevelsData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "PreloadLevels");

	Params::PhxLevelStreamingManager_PreloadLevels Parms{};

	Parms.PreloadLevelsData = PreloadLevelsData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingManager.TransitionCompleted
// (Final, Native, Public, BlueprintCallable)

void UPhxLevelStreamingManager::TransitionCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "TransitionCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingManager.TransitionToLevel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      TransitionEvent                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    WaitForTransitionCompleted                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelStreamingManager::TransitionToLevel(const class FString& LevelName, const class FName& TransitionEvent, bool WaitForTransitionCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "TransitionToLevel");

	Params::PhxLevelStreamingManager_TransitionToLevel Parms{};

	Parms.LevelName = std::move(LevelName);
	Parms.TransitionEvent = TransitionEvent;
	Parms.WaitForTransitionCompleted = WaitForTransitionCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingManager.TransitionToLevelWithAsset
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class ULevelTransitionDataAsset*  LevelTransitionData                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            ActorsToPreserveForTransition                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bSkipPlayerCheck                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLevelStreamingManager::TransitionToLevelWithAsset(const class ULevelTransitionDataAsset* LevelTransitionData, const TArray<class AActor*>& ActorsToPreserveForTransition, bool bSkipPlayerCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "TransitionToLevelWithAsset");

	Params::PhxLevelStreamingManager_TransitionToLevelWithAsset Parms{};

	Parms.LevelTransitionData = LevelTransitionData;
	Parms.ActorsToPreserveForTransition = std::move(ActorsToPreserveForTransition);
	Parms.bSkipPlayerCheck = bSkipPlayerCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLevelStreamingManager.IsInStreamingTransition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxLevelStreamingManager::IsInStreamingTransition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLevelStreamingManager", "IsInStreamingTransition");

	Params::PhxLevelStreamingManager_IsInStreamingTransition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLevelStreamingBlueprintLibrary.GetStreamingVolumesNearActor
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIncludeTransitionVolumes                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UPhxLevelStreamingBlueprintLibrary::GetStreamingVolumesNearActor(class AActor* Actor, bool bIncludeTransitionVolumes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxLevelStreamingBlueprintLibrary", "GetStreamingVolumesNearActor");

	Params::PhxLevelStreamingBlueprintLibrary_GetStreamingVolumesNearActor Parms{};

	Parms.Actor = Actor;
	Parms.bIncludeTransitionVolumes = bIncludeTransitionVolumes;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLightBlueprintLibrary.SetAffectsWorld
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ULightComponentBase*              LightComponentBase                                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAffectsWorld                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLightBlueprintLibrary::SetAffectsWorld(class ULightComponentBase* LightComponentBase, bool bAffectsWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxLightBlueprintLibrary", "SetAffectsWorld");

	Params::PhxLightBlueprintLibrary_SetAffectsWorld Parms{};

	Parms.LightComponentBase = LightComponentBase;
	Parms.bAffectsWorld = bAffectsWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLightFlickerController.InitializeFlickerController
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCurveFloat*                      InFlickerCurve                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class ULightComponent*>&   InLightComponents                                      (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<float>&                    InLightIntensities                                     (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UTimelineComponent*               InTimelineComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLightFlickerController::InitializeFlickerController(class UCurveFloat* InFlickerCurve, const TArray<class ULightComponent*>& InLightComponents, const TArray<float>& InLightIntensities, class UTimelineComponent* InTimelineComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLightFlickerController", "InitializeFlickerController");

	Params::PhxLightFlickerController_InitializeFlickerController Parms{};

	Parms.InFlickerCurve = InFlickerCurve;
	Parms.InLightComponents = std::move(InLightComponents);
	Parms.InLightIntensities = std::move(InLightIntensities);
	Parms.InTimelineComp = InTimelineComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLightFlickerController.UpdateTimeFunc
// (Final, Native, Public)
// Parameters:
// float                                   Output                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLightFlickerController::UpdateTimeFunc(float Output)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLightFlickerController", "UpdateTimeFunc");

	Params::PhxLightFlickerController_UpdateTimeFunc Parms{};

	Parms.Output = Output;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLimbActor.OnHit
// (Final, Native, Private, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

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

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLimbActor", "OnHit");

	Params::PhxLimbActor_OnHit Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxLimbActor.OnLimbReplicaFinished
// (Event, Public, BlueprintEvent)
// Parameters:
// const class USkeletalMeshComponent*     MainCopiedPart                                         (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxLimbActor::OnLimbReplicaFinished(const class USkeletalMeshComponent* MainCopiedPart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLimbActor", "OnLimbReplicaFinished");

	Params::PhxLimbActor_OnLimbReplicaFinished Parms{};

	Parms.MainCopiedPart = MainCopiedPart;

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


// Function Phoenix.PhxLootDropFilter.PrepareForFiltering
// (Event, Public, BlueprintEvent)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxLootDropFilter::PrepareForFiltering(const class APhxCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLootDropFilter", "PrepareForFiltering");

	Params::PhxLootDropFilter_PrepareForFiltering Parms{};

	Parms.Character = Character;

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


// Function Phoenix.PhxLootDropFilter.IsTableEntryValid
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class APhxCharacter*              Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPhxLootDropData&          LootDropEntry                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxLootDropFilter::IsTableEntryValid(const class APhxCharacter* Character, const struct FPhxLootDropData& LootDropEntry) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLootDropFilter", "IsTableEntryValid");

	Params::PhxLootDropFilter_IsTableEntryValid Parms{};

	Parms.Character = Character;
	Parms.LootDropEntry = std::move(LootDropEntry);

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxLootSpawnNode.OnActorRestored
// (Final, Native, Protected)

void APhxLootSpawnNode::OnActorRestored()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxLootSpawnNode", "OnActorRestored");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMarketingCameraHud.OnDpadDown
// (Event, Public, BlueprintEvent)

void APhxMarketingCameraHud::OnDpadDown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnDpadDown");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMarketingCameraHud.OnDpadLeft
// (Event, Public, BlueprintEvent)

void APhxMarketingCameraHud::OnDpadLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnDpadLeft");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMarketingCameraHud.OnDpadRight
// (Event, Public, BlueprintEvent)

void APhxMarketingCameraHud::OnDpadRight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnDpadRight");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMarketingCameraHud.OnDpadUp
// (Event, Public, BlueprintEvent)

void APhxMarketingCameraHud::OnDpadUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnDpadUp");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMarketingCameraHud.OnHudActivated
// (Event, Public, BlueprintEvent)

void APhxMarketingCameraHud::OnHudActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnHudActivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMarketingCameraHud.OnHudDeactivated
// (Event, Public, BlueprintEvent)

void APhxMarketingCameraHud::OnHudDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnHudDeactivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMarketingCameraHud.OnLeftStickAxisHorizontal
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   StickVal                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMarketingCameraHud::OnLeftStickAxisHorizontal(float StickVal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnLeftStickAxisHorizontal");

	Params::PhxMarketingCameraHud_OnLeftStickAxisHorizontal Parms{};

	Parms.StickVal = StickVal;

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


// Function Phoenix.PhxMarketingCameraHud.OnLeftStickAxisVertical
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   StickVal                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxMarketingCameraHud::OnLeftStickAxisVertical(float StickVal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnLeftStickAxisVertical");

	Params::PhxMarketingCameraHud_OnLeftStickAxisVertical Parms{};

	Parms.StickVal = StickVal;

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


// Function Phoenix.PhxMarketingCameraHud.OnUIConfirm
// (Event, Public, BlueprintEvent)

void APhxMarketingCameraHud::OnUIConfirm()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMarketingCameraHud", "OnUIConfirm");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxMeleeAttackDefinition.HasCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EContextualAttackConditions             Condition                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxMeleeAttackDefinition::HasCondition(EContextualAttackConditions Condition) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMeleeAttackDefinition", "HasCondition");

	Params::PhxMeleeAttackDefinition_HasCondition Parms{};

	Parms.Condition = Condition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMemoryReportingLibrary.DumpCharacters
// (Final, Native, Static, Public, BlueprintCallable)

void UPhxMemoryReportingLibrary::DumpCharacters()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxMemoryReportingLibrary", "DumpCharacters");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMemoryReportingLibrary.DumpMeshData
// (Final, Native, Static, Public, BlueprintCallable)

void UPhxMemoryReportingLibrary::DumpMeshData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxMemoryReportingLibrary", "DumpMeshData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMemoryReportingLibrary.DumpMorphTargetData
// (Final, Native, Static, Public, BlueprintCallable)

void UPhxMemoryReportingLibrary::DumpMorphTargetData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxMemoryReportingLibrary", "DumpMorphTargetData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMenuReaderComponent.AsyncLoadAudio
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class FName>&              InTags                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxMenuReaderComponent::AsyncLoadAudio(const TArray<class FName>& InTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenuReaderComponent", "AsyncLoadAudio");

	Params::PhxMenuReaderComponent_AsyncLoadAudio Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMenuReaderComponent.PlayMappedSound
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      InTag                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMenuReaderComponent::PlayMappedSound(const class FName& InTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMenuReaderComponent", "PlayMappedSound");

	Params::PhxMenuReaderComponent_PlayMappedSound Parms{};

	Parms.InTag = InTag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMeshMergeFunctionLibrary.MergeMeshes
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPhxSkeletalMeshMergeParams&Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class USkeletalMesh*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMesh* UPhxMeshMergeFunctionLibrary::MergeMeshes(const struct FPhxSkeletalMeshMergeParams& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxMeshMergeFunctionLibrary", "MergeMeshes");

	Params::PhxMeshMergeFunctionLibrary_MergeMeshes Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SecureSafe.InteractExecuted
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASecureSafe::InteractExecuted(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SecureSafe", "InteractExecuted");

	Params::SecureSafe_InteractExecuted Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SecureSafe.OnKeypadCodeConfirmed
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bUnlocked                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASecureSafe::OnKeypadCodeConfirmed(bool bUnlocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SecureSafe", "OnKeypadCodeConfirmed");

	Params::SecureSafe_OnKeypadCodeConfirmed Parms{};

	Parms.bUnlocked = bUnlocked;

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


// Function Phoenix.SecureSafe.ReceiveKeypadCodeConfirmed
// (Final, Native, Protected)
// Parameters:
// bool                                    bUnlocked                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASecureSafe::ReceiveKeypadCodeConfirmed(bool bUnlocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SecureSafe", "ReceiveKeypadCodeConfirmed");

	Params::SecureSafe_ReceiveKeypadCodeConfirmed Parms{};

	Parms.bUnlocked = bUnlocked;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SecureSafe.GetKeypadUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWSSafeKeypadUI*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSSafeKeypadUI* ASecureSafe::GetKeypadUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SecureSafe", "GetKeypadUI");

	Params::SecureSafe_GetKeypadUI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMuckComponent.AddSimpleEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      Name_0                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxMuckType                            Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FadeInTime                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FadeOutTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMuckComponent::AddSimpleEffect(const class FName& Name_0, EPhxMuckType Type, float Intensity, float Level, float FadeInTime, float FadeOutTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMuckComponent", "AddSimpleEffect");

	Params::PhxMuckComponent_AddSimpleEffect Parms{};

	Parms.Name_0 = Name_0;
	Parms.Type = Type;
	Parms.Intensity = Intensity;
	Parms.Level = Level;
	Parms.FadeInTime = FadeInTime;
	Parms.FadeOutTime = FadeOutTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMuckComponent.IsInEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EPhxMuckType                            Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor**                          Owner                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName*                            Name_0                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  TargetLevel                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsFadingOut                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxMuckComponent::IsInEffect(EPhxMuckType Type, class AActor** Owner, class FName* Name_0, float* TargetLevel, bool* IsFadingOut)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMuckComponent", "IsInEffect");

	Params::PhxMuckComponent_IsInEffect Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxMuckComponent.OverwriteMaterials
// (Final, Native, Public, BlueprintCallable)

void UPhxMuckComponent::OverwriteMaterials()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMuckComponent", "OverwriteMaterials");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMuckComponent.RemoveSimpleEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      Name_0                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMuckComponent::RemoveSimpleEffect(const class FName& Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMuckComponent", "RemoveSimpleEffect");

	Params::PhxMuckComponent_RemoveSimpleEffect Parms{};

	Parms.Name_0 = Name_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSInventoryUI.GetInventoryWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInventoryFrame*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInventoryFrame* AWSInventoryUI::GetInventoryWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInventoryUI", "GetInventoryWidget");

	Params::WSInventoryUI_GetInventoryWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSInventoryUI.GetSelectables
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AWSSelectable*>            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AWSSelectable*> AWSInventoryUI::GetSelectables() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInventoryUI", "GetSelectables");

	Params::WSInventoryUI_GetSelectables Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSInventoryUI.GetWorldLocationOnCylinder
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector2D&                 ElementLocation                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        OutRotator                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AWSInventoryUI::GetWorldLocationOnCylinder(const struct FVector2D& ElementLocation, struct FVector* OutLocation, struct FRotator* OutRotator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInventoryUI", "GetWorldLocationOnCylinder");

	Params::WSInventoryUI_GetWorldLocationOnCylinder Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Phoenix.PhxMusicManager.EnableCombatMusic
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxEncounterIntensity                  CombatIntensity                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    StartOnPreCombat                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    BypassKickoff                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IntensityCanDrop                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KickoffDelayInSeconds                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::EnableCombatMusic(EPhxEncounterIntensity CombatIntensity, bool StartOnPreCombat, bool BypassKickoff, bool IntensityCanDrop, float KickoffDelayInSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "EnableCombatMusic");

	Params::PhxMusicManager_EnableCombatMusic Parms{};

	Parms.CombatIntensity = CombatIntensity;
	Parms.StartOnPreCombat = StartOnPreCombat;
	Parms.BypassKickoff = BypassKickoff;
	Parms.IntensityCanDrop = IntensityCanDrop;
	Parms.KickoffDelayInSeconds = KickoffDelayInSeconds;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnAllEnemiesOfClassUnawareOfPlayer
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           LastEnemy                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnAllEnemiesOfClassUnawareOfPlayer(class UPhxAIGameStateManager* GameStateManager, class AActor* LastEnemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnAllEnemiesOfClassUnawareOfPlayer");

	Params::PhxMusicManager_OnAllEnemiesOfClassUnawareOfPlayer Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.LastEnemy = LastEnemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnCombatStateChanged
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         PreviousGameState                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         NewGameState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnCombatStateChanged(class UPhxAIGameStateManager* GameStateManager, EPhxAIGameState PreviousGameState, EPhxAIGameState NewGameState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnCombatStateChanged");

	Params::PhxMusicManager_OnCombatStateChanged Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.PreviousGameState = PreviousGameState;
	Parms.NewGameState = NewGameState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnEnemyDamaged
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnEnemyDamaged(class UPhxAIGameStateManager* GameStateManager, class AActor* Enemy, class AActor* DamageCauser, const class UDamageType* DamageType, float Damage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnEnemyDamaged");

	Params::PhxMusicManager_OnEnemyDamaged Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.DamageCauser = DamageCauser;
	Parms.DamageType = DamageType;
	Parms.Damage = Damage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnEnemyDied
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnEnemyDied(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnEnemyDied");

	Params::PhxMusicManager_OnEnemyDied Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnEnemySpawned
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnEnemySpawned(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnEnemySpawned");

	Params::PhxMusicManager_OnEnemySpawned Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnFirstEnemyOfClassAwareOfPlayer
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           FirstEnemy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnFirstEnemyOfClassAwareOfPlayer(class UPhxAIGameStateManager* GameStateManager, class AActor* FirstEnemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnFirstEnemyOfClassAwareOfPlayer");

	Params::PhxMusicManager_OnFirstEnemyOfClassAwareOfPlayer Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.FirstEnemy = FirstEnemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnLastEnemyDied
// (Final, Native, Public)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnLastEnemyDied(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnLastEnemyDied");

	Params::PhxMusicManager_OnLastEnemyDied Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnPlayerDamaged
// (Final, Native, Public)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnPlayerDamaged(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnPlayerDamaged");

	Params::PhxMusicManager_OnPlayerDamaged Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnPlayerDied
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnPlayerDied(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnPlayerDied");

	Params::PhxMusicManager_OnPlayerDied Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnQteCanceled
// (Final, Native, Public)
// Parameters:
// class FName                             QteId                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnQteCanceled(class FName QteId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnQteCanceled");

	Params::PhxMusicManager_OnQteCanceled Parms{};

	Parms.QteId = QteId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnQteComplete
// (Final, Native, Public)
// Parameters:
// class FName                             QteId                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResult                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnQteComplete(class FName QteId, bool bResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnQteComplete");

	Params::PhxMusicManager_OnQteComplete Parms{};

	Parms.QteId = QteId;
	Parms.bResult = bResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnQteStarted
// (Final, Native, Public)

void UPhxMusicManager::OnQteStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnQteStarted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.OnSoundEventCallback
// (Final, Native, Public)
// Parameters:
// EAkCallbackType                         CallbackType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  CallbackInfo                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::OnSoundEventCallback(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "OnSoundEventCallback");

	Params::PhxMusicManager_OnSoundEventCallback Parms{};

	Parms.CallbackType = CallbackType;
	Parms.CallbackInfo = CallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.PostMusicEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    musicEvent                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::PostMusicEvent(class UAkAudioEvent* musicEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "PostMusicEvent");

	Params::PhxMusicManager_PostMusicEvent Parms{};

	Parms.musicEvent = musicEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.SetRTPC
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkRtpc*                          RtpcIn                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::SetRTPC(class UAkRtpc* RtpcIn, float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "SetRTPC");

	Params::PhxMusicManager_SetRTPC Parms{};

	Parms.RtpcIn = RtpcIn;
	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxMusicManager.SetSwitch
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkSwitchValue*                   SwitchIn                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxMusicManager::SetSwitch(class UAkSwitchValue* SwitchIn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxMusicManager", "SetSwitch");

	Params::PhxMusicManager_SetSwitch Parms{};

	Parms.SwitchIn = SwitchIn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPigPlatform.OnPigSpeedUpdated
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   NewSpeed                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPigPlatform::OnPigSpeedUpdated(float NewSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPigPlatform", "OnPigSpeedUpdated");

	Params::PhxPigPlatform_OnPigSpeedUpdated Parms{};

	Parms.NewSpeed = NewSpeed;

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


// Function Phoenix.PhxPigPlatform.SetShouldTiltPlatform
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bShouldTilt                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResetRoll                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPigPlatform::SetShouldTiltPlatform(bool bShouldTilt, bool bResetRoll)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPigPlatform", "SetShouldTiltPlatform");

	Params::PhxPigPlatform_SetShouldTiltPlatform Parms{};

	Parms.bShouldTilt = bShouldTilt;
	Parms.bResetRoll = bResetRoll;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPigPlatform.ForceSleepRagdollsOnPlatform
// (Final, Native, Protected, BlueprintCallable, Const)

void APhxPigPlatform::ForceSleepRagdollsOnPlatform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPigPlatform", "ForceSleepRagdollsOnPlatform");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.AddAmmoToInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   AmmoToAdd                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::AddAmmoToInventory(int32 AmmoToAdd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "AddAmmoToInventory");

	Params::PhxPlayerCharacter_AddAmmoToInventory Parms{};

	Parms.AmmoToAdd = AmmoToAdd;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.CancelHardCameraLookAtLookAt
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerCharacter::CancelHardCameraLookAtLookAt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "CancelHardCameraLookAtLookAt");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.CancelSoftCameraLookAtLookAt
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerCharacter::CancelSoftCameraLookAtLookAt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "CancelSoftCameraLookAtLookAt");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.CheckIfCloseToWall
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerCharacter::CheckIfCloseToWall()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "CheckIfCloseToWall");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.DamagePlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DamageAmount                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsLethal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::DamagePlayer(float DamageAmount, bool bIsLethal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "DamagePlayer");

	Params::PhxPlayerCharacter_DamagePlayer Parms{};

	Parms.DamageAmount = DamageAmount;
	Parms.bIsLethal = bIsLethal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.EndAllCameraTransitions
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerCharacter::EndAllCameraTransitions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "EndAllCameraTransitions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.ExitPipeSlide
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerCharacter::ExitPipeSlide()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "ExitPipeSlide");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.GetItemDropsHistory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<TSoftClassPtr<class UClass>>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)

const TArray<TSoftClassPtr<class UClass>> APhxPlayerCharacter::GetItemDropsHistory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "GetItemDropsHistory");

	Params::PhxPlayerCharacter_GetItemDropsHistory Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCharacter.HandleAIGameStateChanged
// (Final, Native, Private)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         PreviousGameState                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxAIGameState                         NewGameState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::HandleAIGameStateChanged(class UPhxAIGameStateManager* GameStateManager, EPhxAIGameState PreviousGameState, EPhxAIGameState NewGameState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "HandleAIGameStateChanged");

	Params::PhxPlayerCharacter_HandleAIGameStateChanged Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.PreviousGameState = PreviousGameState;
	Parms.NewGameState = NewGameState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.HasDLCEntitlement
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const TArray<bool>&                     EntitlementResults                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::HasDLCEntitlement(const TArray<bool>& EntitlementResults)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "HasDLCEntitlement");

	Params::PhxPlayerCharacter_HasDLCEntitlement Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.HealPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   HealAmount                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::HealPlayer(float HealAmount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "HealPlayer");

	Params::PhxPlayerCharacter_HealPlayer Parms{};

	Parms.HealAmount = HealAmount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnDefensiveActionEnded
// (Final, Native, Public)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnDefensiveActionEnded(EReactionType ReactionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnDefensiveActionEnded");

	Params::PhxPlayerCharacter_OnDefensiveActionEnded Parms{};

	Parms.ReactionType = ReactionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnDefensiveActionStarted
// (Final, Native, Public, HasOutParams)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnDefensiveActionStarted(EReactionType ReactionType, EDefensiveReactDirection ReactionDir, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnDefensiveActionStarted");

	Params::PhxPlayerCharacter_OnDefensiveActionStarted Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnEquipmentModifiedUpdateBlackBox
// (Final, Native, Public)
// Parameters:
// class AEquippable*                      CurrentEquipped                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEquippable*                      CurrentEquippedAux                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnEquipmentModifiedUpdateBlackBox(class AEquippable* CurrentEquipped, class AEquippable* CurrentEquippedAux)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnEquipmentModifiedUpdateBlackBox");

	Params::PhxPlayerCharacter_OnEquipmentModifiedUpdateBlackBox Parms{};

	Parms.CurrentEquipped = CurrentEquipped;
	Parms.CurrentEquippedAux = CurrentEquippedAux;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnGrappled
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrappledPuppetState*             GrappledPuppetState                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnGrappled(class APhxCharacter* PlayerCharacter, class UGrappledPuppetState* GrappledPuppetState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnGrappled");

	Params::PhxPlayerCharacter_OnGrappled Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.GrappledPuppetState = GrappledPuppetState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnHealthModified
// (Final, Native, Public)
// Parameters:
// class UPhxHealthComponent*              HealthComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnHealthModified(class UPhxHealthComponent* HealthComponent, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnHealthModified");

	Params::PhxPlayerCharacter_OnHealthModified Parms{};

	Parms.HealthComponent = HealthComponent;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnHealthModifiedUpdateBlackBox
// (Final, Native, Public)
// Parameters:
// class UPhxHealthComponent*              HealthComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Health                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HealthDelta                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnHealthModifiedUpdateBlackBox(class UPhxHealthComponent* HealthComponent, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnHealthModifiedUpdateBlackBox");

	Params::PhxPlayerCharacter_OnHealthModifiedUpdateBlackBox Parms{};

	Parms.HealthComponent = HealthComponent;
	Parms.Health = Health;
	Parms.HealthDelta = HealthDelta;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnItemCountModifiedUpdateBlackBox
// (Final, Native, Public, HasOutParams)
// Parameters:
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnItemCountModifiedUpdateBlackBox(const class FName& ItemName, int32 Quantity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnItemCountModifiedUpdateBlackBox");

	Params::PhxPlayerCharacter_OnItemCountModifiedUpdateBlackBox Parms{};

	Parms.ItemName = ItemName;
	Parms.Quantity = Quantity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.OnMeleeAimSnapWindowBegin
// (Event, Public, BlueprintEvent)

void APhxPlayerCharacter::OnMeleeAimSnapWindowBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnMeleeAimSnapWindowBegin");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPlayerCharacter.OnMeleeAimSnapWindowEnd
// (Event, Public, BlueprintEvent)

void APhxPlayerCharacter::OnMeleeAimSnapWindowEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnMeleeAimSnapWindowEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPlayerCharacter.OnWeaponSkinChanged
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayTag&              WeaponTag                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::OnWeaponSkinChanged(const struct FGameplayTag& WeaponTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "OnWeaponSkinChanged");

	Params::PhxPlayerCharacter_OnWeaponSkinChanged Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.PROTOTYPE_RequestEnterPipeSlide
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APipeSlideSpline*                 SplineActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::PROTOTYPE_RequestEnterPipeSlide(class APipeSlideSpline* SplineActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "PROTOTYPE_RequestEnterPipeSlide");

	Params::PhxPlayerCharacter_PROTOTYPE_RequestEnterPipeSlide Parms{};

	Parms.SplineActor = SplineActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.RemoveAmmoFromInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   AmmoToRemove                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::RemoveAmmoFromInventory(int32 AmmoToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "RemoveAmmoFromInventory");

	Params::PhxPlayerCharacter_RemoveAmmoFromInventory Parms{};

	Parms.AmmoToRemove = AmmoToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.RequestEnterChainLadder
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AChainLadder*                     ChainLadder                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::RequestEnterChainLadder(class AChainLadder* ChainLadder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "RequestEnterChainLadder");

	Params::PhxPlayerCharacter_RequestEnterChainLadder Parms{};

	Parms.ChainLadder = ChainLadder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.RequestHardCameraLookAt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TargetBone                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendInTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendOutTime                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AbortDistance                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::RequestHardCameraLookAt(class AActor* TargetActor, class FName TargetBone, float BlendInTime, float BlendOutTime, float Duration, float AbortDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "RequestHardCameraLookAt");

	Params::PhxPlayerCharacter_RequestHardCameraLookAt Parms{};

	Parms.TargetActor = TargetActor;
	Parms.TargetBone = TargetBone;
	Parms.BlendInTime = BlendInTime;
	Parms.BlendOutTime = BlendOutTime;
	Parms.Duration = Duration;
	Parms.AbortDistance = AbortDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.RequestLinkedNodeTraversal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxTraversalNode*                InNode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::RequestLinkedNodeTraversal(class APhxTraversalNode* InNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "RequestLinkedNodeTraversal");

	Params::PhxPlayerCharacter_RequestLinkedNodeTraversal Parms{};

	Parms.InNode = InNode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.RequestMontageAttachStateEnter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPhxMontageAttachStateRequest&InRequest                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::RequestMontageAttachStateEnter(const struct FPhxMontageAttachStateRequest& InRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "RequestMontageAttachStateEnter");

	Params::PhxPlayerCharacter_RequestMontageAttachStateEnter Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.RequestMontageAttachStateExit
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerCharacter::RequestMontageAttachStateExit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "RequestMontageAttachStateExit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.RequestSoftCameraLookAt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TargetBone                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendInTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   UninterruptableDuration                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AbortDistance                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::RequestSoftCameraLookAt(class AActor* TargetActor, class FName TargetBone, float BlendInTime, float Duration, float UninterruptableDuration, float AbortDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "RequestSoftCameraLookAt");

	Params::PhxPlayerCharacter_RequestSoftCameraLookAt Parms{};

	Parms.TargetActor = TargetActor;
	Parms.TargetBone = TargetBone;
	Parms.BlendInTime = BlendInTime;
	Parms.Duration = Duration;
	Parms.UninterruptableDuration = UninterruptableDuration;
	Parms.AbortDistance = AbortDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.ResetConsecutiveDodgeCount
// (Final, Native, Public)

void APhxPlayerCharacter::ResetConsecutiveDodgeCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "ResetConsecutiveDodgeCount");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.SavePlayerMovementBaseLocation
// (Final, Native, Public, BlueprintCallable)

void APhxPlayerCharacter::SavePlayerMovementBaseLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "SavePlayerMovementBaseLocation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.SetCanOpenInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bSet                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::SetCanOpenInventory(bool bSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "SetCanOpenInventory");

	Params::PhxPlayerCharacter_SetCanOpenInventory Parms{};

	Parms.bSet = bSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.SetCanPlayerSprint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bCanSprint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::SetCanPlayerSprint(bool bCanSprint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "SetCanPlayerSprint");

	Params::PhxPlayerCharacter_SetCanPlayerSprint Parms{};

	Parms.bCanSprint = bCanSprint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.Teleport
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                InTransform                                            (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bTeleportToFeetLocation                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResetControlRotation                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::Teleport(const struct FTransform& InTransform, bool bTeleportToFeetLocation, bool bResetControlRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "Teleport");

	Params::PhxPlayerCharacter_Teleport Parms{};

	Parms.InTransform = std::move(InTransform);
	Parms.bTeleportToFeetLocation = bTeleportToFeetLocation;
	Parms.bResetControlRotation = bResetControlRotation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.TeleportToCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ACheckpoint*                      Checkpoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::TeleportToCheckpoint(class ACheckpoint* Checkpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "TeleportToCheckpoint");

	Params::PhxPlayerCharacter_TeleportToCheckpoint Parms{};

	Parms.Checkpoint = Checkpoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerCharacter.CanPlayerSprint
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const bool APhxPlayerCharacter::CanPlayerSprint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "CanPlayerSprint");

	Params::PhxPlayerCharacter_CanPlayerSprint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCharacter.GetFlashlightSupplementalLights
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// TArray<struct FPhxFlashlightSupplementalLightRegistrationData>*OutLightComponents                                     (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxPlayerCharacter::GetFlashlightSupplementalLights(TArray<struct FPhxFlashlightSupplementalLightRegistrationData>* OutLightComponents) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "GetFlashlightSupplementalLights");

	Params::PhxPlayerCharacter_GetFlashlightSupplementalLights Parms{};

	UObject::ProcessEvent(Func, &Parms);

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


// Function Phoenix.PhxPlayerCharacter.GetGRPAttachmentPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   RelativePullAndHoldOffset                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector APhxPlayerCharacter::GetGRPAttachmentPoint(const struct FVector& RelativePullAndHoldOffset) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "GetGRPAttachmentPoint");

	Params::PhxPlayerCharacter_GetGRPAttachmentPoint Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCharacter.GetGRPAttachmentRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator APhxPlayerCharacter::GetGRPAttachmentRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "GetGRPAttachmentRotation");

	Params::PhxPlayerCharacter_GetGRPAttachmentRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCharacter.HasMoveDirection
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerCharacter::HasMoveDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "HasMoveDirection");

	Params::PhxPlayerCharacter_HasMoveDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCharacter.IsInCombat
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPlayerCharacter::IsInCombat() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacter", "IsInCombat");

	Params::PhxPlayerCharacter_IsInCombat Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerCharacterAnimInstance.StartWeaponHolsterDynamicsBlend
// (Final, Native, Public, BlueprintCallable)

void UPhxPlayerCharacterAnimInstance::StartWeaponHolsterDynamicsBlend()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerCharacterAnimInstance", "StartWeaponHolsterDynamicsBlend");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.RecyclerWidget.GenerateMenu
// (Final, Native, Public, BlueprintCallable)

void URecyclerWidget::GenerateMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecyclerWidget", "GenerateMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.RecyclerWidget.ShowOutputMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   numMetals                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   numBioplastics                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   numChemicals                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URecyclerWidget::ShowOutputMenu(int32 numMetals, int32 numBioplastics, int32 numChemicals)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecyclerWidget", "ShowOutputMenu");

	Params::RecyclerWidget_ShowOutputMenu Parms{};

	Parms.numMetals = numMetals;
	Parms.numBioplastics = numBioplastics;
	Parms.numChemicals = numChemicals;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.RecyclerWidget.ShowPreRecycleMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   numSalvage                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URecyclerWidget::ShowPreRecycleMenu(int32 numSalvage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecyclerWidget", "ShowPreRecycleMenu");

	Params::RecyclerWidget_ShowPreRecycleMenu Parms{};

	Parms.numSalvage = numSalvage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.RecyclerWidget.ShowUnusedMenu
// (Final, Native, Public, BlueprintCallable)

void URecyclerWidget::ShowUnusedMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecyclerWidget", "ShowUnusedMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.AddNewWidgetToViewport
// (Final, Native, Public)
// Parameters:
// TSubclassOf<class UUserWidget>          WidgetClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUserWidget*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUserWidget* UPhxPlayerControllerUIComponent::AddNewWidgetToViewport(TSubclassOf<class UUserWidget> WidgetClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "AddNewWidgetToViewport");

	Params::PhxPlayerControllerUIComponent_AddNewWidgetToViewport Parms{};

	Parms.WidgetClass = WidgetClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetOutOfAmmoUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class USDSSimpleNotification*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSSimpleNotification* UPhxPlayerControllerUIComponent::GetOutOfAmmoUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetOutOfAmmoUI");

	Params::PhxPlayerControllerUIComponent_GetOutOfAmmoUI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.HideSubObjectiveUI
// (Final, Native, Public, BlueprintCallable)

void UPhxPlayerControllerUIComponent::HideSubObjectiveUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "HideSubObjectiveUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.OnDialogueEnded
// (Final, Native, Protected)
// Parameters:
// class UDialogue*                        Dialogue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::OnDialogueEnded(class UDialogue* Dialogue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "OnDialogueEnded");

	Params::PhxPlayerControllerUIComponent_OnDialogueEnded Parms{};

	Parms.Dialogue = Dialogue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.OpenLevelFromMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxPlayerControllerUIComponent::OpenLevelFromMenu(int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "OpenLevelFromMenu");

	Params::PhxPlayerControllerUIComponent_OpenLevelFromMenu Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.OpenMainMenu
// (Final, Native, Public, BlueprintCallable)

void UPhxPlayerControllerUIComponent::OpenMainMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "OpenMainMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.RegisterAllLevelChunkDelegates
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void(float Progress)>&  ProgressDelegate                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void(EChunkDelegateStatus Status)>&CompletionDelegate                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::RegisterAllLevelChunkDelegates(const TDelegate<void(float Progress)>& ProgressDelegate, const TDelegate<void(EChunkDelegateStatus Status)>& CompletionDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "RegisterAllLevelChunkDelegates");

	Params::PhxPlayerControllerUIComponent_RegisterAllLevelChunkDelegates Parms{};

	Parms.ProgressDelegate = ProgressDelegate;
	Parms.CompletionDelegate = CompletionDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.RegisterLevelChunkDelegates
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   LevelIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(float Progress)>&  ProgressDelegate                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void(EChunkDelegateStatus Status)>&CompletionDelegate                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::RegisterLevelChunkDelegates(int32 LevelIndex, const TDelegate<void(float Progress)>& ProgressDelegate, const TDelegate<void(EChunkDelegateStatus Status)>& CompletionDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "RegisterLevelChunkDelegates");

	Params::PhxPlayerControllerUIComponent_RegisterLevelChunkDelegates Parms{};

	Parms.LevelIndex = LevelIndex;
	Parms.ProgressDelegate = ProgressDelegate;
	Parms.CompletionDelegate = CompletionDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.RemoveAllWidgets
// (Net, NetReliable, Native, Event, Public, NetClient)

void UPhxPlayerControllerUIComponent::RemoveAllWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "RemoveAllWidgets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.RequestOutOfAmmoNotification
// (Final, Native, Public, BlueprintCallable)

void UPhxPlayerControllerUIComponent::RequestOutOfAmmoNotification()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "RequestOutOfAmmoNotification");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.RequestOutOfChargeNotification
// (Final, Native, Public, BlueprintCallable)

void UPhxPlayerControllerUIComponent::RequestOutOfChargeNotification()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "RequestOutOfChargeNotification");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.RequestQuit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::RequestQuit(bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "RequestQuit");

	Params::PhxPlayerControllerUIComponent_RequestQuit Parms{};

	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.RequestUINotification
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FNotificationData&         Notification                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::RequestUINotification(const struct FNotificationData& Notification)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "RequestUINotification");

	Params::PhxPlayerControllerUIComponent_RequestUINotification Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.SetRequestDeathScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    RequestDeath                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::SetRequestDeathScreen(bool RequestDeath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "SetRequestDeathScreen");

	Params::PhxPlayerControllerUIComponent_SetRequestDeathScreen Parms{};

	Parms.RequestDeath = RequestDeath;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.SetRequestLogoScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    RequestLogo                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::SetRequestLogoScreen(bool RequestLogo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "SetRequestLogoScreen");

	Params::PhxPlayerControllerUIComponent_SetRequestLogoScreen Parms{};

	Parms.RequestLogo = RequestLogo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.SetRequestTransitionScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    RequestTransition                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxPlayerControllerUIComponent::SetRequestTransitionScreen(bool RequestTransition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "SetRequestTransitionScreen");

	Params::PhxPlayerControllerUIComponent_SetRequestTransitionScreen Parms{};

	Parms.RequestTransition = RequestTransition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.StopAudioLog
// (Final, Native, Public, BlueprintCallable)

void UPhxPlayerControllerUIComponent::StopAudioLog()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "StopAudioLog");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetActionForInputKey
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxInputKeys                           InKey                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FActionMapKey              ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FActionMapKey UPhxPlayerControllerUIComponent::GetActionForInputKey(EPhxInputKeys InKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetActionForInputKey");

	Params::PhxPlayerControllerUIComponent_GetActionForInputKey Parms{};

	Parms.InKey = InKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetControllerType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPhxControllerType                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxControllerType UPhxPlayerControllerUIComponent::GetControllerType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetControllerType");

	Params::PhxPlayerControllerUIComponent_GetControllerType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetCurrentAudioLog
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UDialogue*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UDialogue* UPhxPlayerControllerUIComponent::GetCurrentAudioLog() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetCurrentAudioLog");

	Params::PhxPlayerControllerUIComponent_GetCurrentAudioLog Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetIconForKey
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxControllerKeys                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxControllerKeys UPhxPlayerControllerUIComponent::GetIconForKey(const struct FKey& InKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetIconForKey");

	Params::PhxPlayerControllerUIComponent_GetIconForKey Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetInputKeyToActionMapping
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxInputKeyToAction*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxInputKeyToAction* UPhxPlayerControllerUIComponent::GetInputKeyToActionMapping() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetInputKeyToActionMapping");

	Params::PhxPlayerControllerUIComponent_GetInputKeyToActionMapping Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetKeyToInputIconMapping
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxKeyToControllerKey*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxKeyToControllerKey* UPhxPlayerControllerUIComponent::GetKeyToInputIconMapping() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetKeyToInputIconMapping");

	Params::PhxPlayerControllerUIComponent_GetKeyToInputIconMapping Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetLevelNames
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class FText>               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class FText> UPhxPlayerControllerUIComponent::GetLevelNames() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetLevelNames");

	Params::PhxPlayerControllerUIComponent_GetLevelNames Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetLevelTags
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FGameplayTag>       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FGameplayTag> UPhxPlayerControllerUIComponent::GetLevelTags() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetLevelTags");

	Params::PhxPlayerControllerUIComponent_GetLevelTags Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetLevelTransitionAssets
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class ULevelTransitionDataAsset*>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class ULevelTransitionDataAsset*> UPhxPlayerControllerUIComponent::GetLevelTransitionAssets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetLevelTransitionAssets");

	Params::PhxPlayerControllerUIComponent_GetLevelTransitionAssets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetMenuTransitionAsset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class ULevelTransitionDataAsset*  ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class ULevelTransitionDataAsset* UPhxPlayerControllerUIComponent::GetMenuTransitionAsset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetMenuTransitionAsset");

	Params::PhxPlayerControllerUIComponent_GetMenuTransitionAsset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerControllerUIComponent.GetPlatformTexturePack
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxPlatformTexturePack*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxPlatformTexturePack* UPhxPlayerControllerUIComponent::GetPlatformTexturePack() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerControllerUIComponent", "GetPlatformTexturePack");

	Params::PhxPlayerControllerUIComponent_GetPlatformTexturePack Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSConfirmHandler.ConfirmPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSConfirmHandler::ConfirmPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSConfirmHandler", "ConfirmPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerMovementComponent.RequestPipeSlideAlignment
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                                   TargetSpeed                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetPos                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  TargetRot                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UPhxPlayerMovementComponent::RequestPipeSlideAlignment(float TargetSpeed, const struct FVector& TargetPos, const struct FRotator& TargetRot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerMovementComponent", "RequestPipeSlideAlignment");

	Params::PhxPlayerMovementComponent_RequestPipeSlideAlignment Parms{};

	Parms.TargetSpeed = TargetSpeed;
	Parms.TargetPos = std::move(TargetPos);
	Parms.TargetRot = std::move(TargetRot);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerState.GetHitCounter
// (Final, Native, Public)
// Parameters:
// class UHitCounter*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UHitCounter* APhxPlayerState::GetHitCounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerState", "GetHitCounter");

	Params::PhxPlayerState_GetHitCounter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPlayerTriggerCapsule.HandleActorBeginOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerTriggerCapsule::HandleActorBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerTriggerCapsule", "HandleActorBeginOverlap");

	Params::PhxPlayerTriggerCapsule_HandleActorBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerTriggerCapsule.HandleActorEndOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerTriggerCapsule::HandleActorEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerTriggerCapsule", "HandleActorEndOverlap");

	Params::PhxPlayerTriggerCapsule_HandleActorEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerTriggerSphere.HandleActorBeginOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerTriggerSphere::HandleActorBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerTriggerSphere", "HandleActorBeginOverlap");

	Params::PhxPlayerTriggerSphere_HandleActorBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPlayerTriggerSphere.HandleActorEndOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxPlayerTriggerSphere::HandleActorEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPlayerTriggerSphere", "HandleActorEndOverlap");

	Params::PhxPlayerTriggerSphere_HandleActorEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPPEImpactListenerInterface.OnImpactedByEnemy
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UPrimitiveComponent*              ImpactedComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  ImpactedByEnemy                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxPPEImpactListenerInterface::OnImpactedByEnemy(class UPrimitiveComponent* ImpactedComponent, class APhxAICharacter* ImpactedByEnemy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxPPEImpactListenerInterface", "OnImpactedByEnemy");

	Params::PhxPPEImpactListenerInterface_OnImpactedByEnemy Parms{};

	Parms.ImpactedComponent = ImpactedComponent;
	Parms.ImpactedByEnemy = ImpactedByEnemy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPPEInteractionInterface.OnHitByPPE
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// EPPEProjectileType                      PPEProjectileType                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ShotDirection                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ShotPower                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ImpactNormal                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPhxPPEInteractionInterface::OnHitByPPE(EPPEProjectileType PPEProjectileType, const struct FVector& ShotDirection, int32 ShotPower, const struct FVector& ImpactNormal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxPPEInteractionInterface", "OnHitByPPE");

	Params::PhxPPEInteractionInterface_OnHitByPPE Parms{};

	Parms.PPEProjectileType = PPEProjectileType;
	Parms.ShotDirection = std::move(ShotDirection);
	Parms.ShotPower = ShotPower;
	Parms.ImpactNormal = std::move(ImpactNormal);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxPrevizVideo.EndPrevizVideo
// (Event, Public, BlueprintCallable, BlueprintEvent)

void APhxPrevizVideo::EndPrevizVideo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrevizVideo", "EndPrevizVideo");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrevizVideo.IsPlaying
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxPrevizVideo::IsPlaying() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrevizVideo", "IsPlaying");

	Params::PhxPrevizVideo_IsPlaying Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxPrintingMeshActor.Initialize
// (Event, Public, BlueprintEvent)

void APhxPrintingMeshActor::Initialize()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrintingMeshActor", "Initialize");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrintingMeshActor.PrepareHologramMaterials
// (Event, Public, BlueprintEvent)

void APhxPrintingMeshActor::PrepareHologramMaterials()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrintingMeshActor", "PrepareHologramMaterials");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrintingMeshActor.PreparePrintingMaterials
// (Event, Public, BlueprintEvent)

void APhxPrintingMeshActor::PreparePrintingMaterials()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrintingMeshActor", "PreparePrintingMaterials");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrintingMeshActor.ShowHologram
// (Event, Public, BlueprintCallable, BlueprintEvent)

void APhxPrintingMeshActor::ShowHologram()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrintingMeshActor", "ShowHologram");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrintingMeshActor.ShowPrintingMesh
// (Event, Public, BlueprintCallable, BlueprintEvent)

void APhxPrintingMeshActor::ShowPrintingMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrintingMeshActor", "ShowPrintingMesh");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrintingMeshActor.StartPrinting
// (Event, Public, BlueprintEvent)

void APhxPrintingMeshActor::StartPrinting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrintingMeshActor", "StartPrinting");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxPrintingMeshActor.StopPrintingAndHide
// (Event, Public, BlueprintEvent)

void APhxPrintingMeshActor::StopPrintingAndHide()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxPrintingMeshActor", "StopPrintingAndHide");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxWorldStateData.AddTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxWorldStateData::AddTag(const struct FGameplayTag& Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "AddTag");

	Params::PhxWorldStateData_AddTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.ClearCounter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Counter                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxWorldStateData::ClearCounter(const struct FGameplayTag& Counter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "ClearCounter");

	Params::PhxWorldStateData_ClearCounter Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.DecrementCounter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Counter                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxWorldStateData::DecrementCounter(const struct FGameplayTag& Counter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "DecrementCounter");

	Params::PhxWorldStateData_DecrementCounter Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.FindAnyWithParentTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              ParentTag                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayTag UPhxWorldStateData::FindAnyWithParentTag(const struct FGameplayTag& ParentTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "FindAnyWithParentTag");

	Params::PhxWorldStateData_FindAnyWithParentTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.IncrementCounter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Counter                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxWorldStateData::IncrementCounter(const struct FGameplayTag& Counter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "IncrementCounter");

	Params::PhxWorldStateData_IncrementCounter Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.RemoveAnyWithParentTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              ParentTag                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxWorldStateData::RemoveAnyWithParentTag(const struct FGameplayTag& ParentTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "RemoveAnyWithParentTag");

	Params::PhxWorldStateData_RemoveAnyWithParentTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.RemoveTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxWorldStateData::RemoveTag(const struct FGameplayTag& Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "RemoveTag");

	Params::PhxWorldStateData_RemoveTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.SetCounter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Counter                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxWorldStateData::SetCounter(const struct FGameplayTag& Counter, int32 Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "SetCounter");

	Params::PhxWorldStateData_SetCounter Parms{};

	Parms.Counter = std::move(Counter);
	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.GetCounterValue
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Counter                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxWorldStateData::GetCounterValue(const struct FGameplayTag& Counter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "GetCounterValue");

	Params::PhxWorldStateData_GetCounterValue Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldStateData.QueryTag
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxWorldStateData::QueryTag(const struct FGameplayTag& Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldStateData", "QueryTag");

	Params::PhxWorldStateData_QueryTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.AddProgressionStatusTag
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ProgressionTag                                         (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::AddProgressionStatusTag(class UObject* WorldContextObject, const struct FGameplayTag& ProgressionTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "AddProgressionStatusTag");

	Params::PhxProgressManager_AddProgressionStatusTag Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ProgressionTag = std::move(ProgressionTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.GetCurrentLevelTags
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayTagContainer UPhxProgressManager::GetCurrentLevelTags(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetCurrentLevelTags");

	Params::PhxProgressManager_GetCurrentLevelTags Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetCurrentLevelWorldState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxWorldStateData*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxWorldStateData* UPhxProgressManager::GetCurrentLevelWorldState(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetCurrentLevelWorldState");

	Params::PhxProgressManager_GetCurrentLevelWorldState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetCurrentObjective
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPhxObjective                    ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FPhxObjective UPhxProgressManager::GetCurrentObjective(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetCurrentObjective");

	Params::PhxProgressManager_GetCurrentObjective Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetDifficulty
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxDifficultyLevel                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxDifficultyLevel UPhxProgressManager::GetDifficulty(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetDifficulty");

	Params::PhxProgressManager_GetDifficulty Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetDLCStoryCompleted
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::GetDLCStoryCompleted(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetDLCStoryCompleted");

	Params::PhxProgressManager_GetDLCStoryCompleted Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetGlobalWorldState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxWorldStateData*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxWorldStateData* UPhxProgressManager::GetGlobalWorldState(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetGlobalWorldState");

	Params::PhxProgressManager_GetGlobalWorldState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetLastCheckpointTimeStamp
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDateTime                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FDateTime UPhxProgressManager::GetLastCheckpointTimeStamp(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetLastCheckpointTimeStamp");

	Params::PhxProgressManager_GetLastCheckpointTimeStamp Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetMainStoryCompleted
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::GetMainStoryCompleted(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetMainStoryCompleted");

	Params::PhxProgressManager_GetMainStoryCompleted Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetManagerState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxProgressManagerState                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhxProgressManagerState UPhxProgressManager::GetManagerState(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetManagerState");

	Params::PhxProgressManager_GetManagerState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetNewGamePlus
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::GetNewGamePlus(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetNewGamePlus");

	Params::PhxProgressManager_GetNewGamePlus Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetPersistentLevelWorldState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxWorldStateData*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxWorldStateData* UPhxProgressManager::GetPersistentLevelWorldState(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetPersistentLevelWorldState");

	Params::PhxProgressManager_GetPersistentLevelWorldState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetPreviousLevelTags
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayTagContainer UPhxProgressManager::GetPreviousLevelTags(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetPreviousLevelTags");

	Params::PhxProgressManager_GetPreviousLevelTags Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetProgressionStatusTags
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bProgressionTagsOnly                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayTagContainer UPhxProgressManager::GetProgressionStatusTags(class UObject* WorldContextObject, bool bProgressionTagsOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetProgressionStatusTags");

	Params::PhxProgressManager_GetProgressionStatusTags Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bProgressionTagsOnly = bProgressionTagsOnly;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetStoryDLC
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::GetStoryDLC(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetStoryDLC");

	Params::PhxProgressManager_GetStoryDLC Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.GetTotalTimePlayed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxProgressManager::GetTotalTimePlayed(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "GetTotalTimePlayed");

	Params::PhxProgressManager_GetTotalTimePlayed Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.HasCurrentObjective
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::HasCurrentObjective(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "HasCurrentObjective");

	Params::PhxProgressManager_HasCurrentObjective Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.HasLastCheckpoint
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::HasLastCheckpoint(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "HasLastCheckpoint");

	Params::PhxProgressManager_HasLastCheckpoint Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.HideSubObjective
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::HideSubObjective(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "HideSubObjective");

	Params::PhxProgressManager_HideSubObjective Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.InitSessionStartTime
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::InitSessionStartTime(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "InitSessionStartTime");

	Params::PhxProgressManager_InitSessionStartTime Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.IsRestoringFromCheckpoint
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::IsRestoringFromCheckpoint(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "IsRestoringFromCheckpoint");

	Params::PhxProgressManager_IsRestoringFromCheckpoint Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProgressManager.RemoveProgressionStatusTags
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ProgressionTag                                         (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::RemoveProgressionStatusTags(class UObject* WorldContextObject, const struct FGameplayTag& ProgressionTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "RemoveProgressionStatusTags");

	Params::PhxProgressManager_RemoveProgressionStatusTags Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ProgressionTag = std::move(ProgressionTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.RestoreLastCheckpointFromContext
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::RestoreLastCheckpointFromContext(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "RestoreLastCheckpointFromContext");

	Params::PhxProgressManager_RestoreLastCheckpointFromContext Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.SetDifficulty
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhxDifficultyLevel                     Difficulty                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::SetDifficulty(class UObject* WorldContextObject, EPhxDifficultyLevel Difficulty)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "SetDifficulty");

	Params::PhxProgressManager_SetDifficulty Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Difficulty = Difficulty;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.SetDLCStoryCompleted
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCompleted                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::SetDLCStoryCompleted(class UObject* WorldContextObject, bool bCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "SetDLCStoryCompleted");

	Params::PhxProgressManager_SetDLCStoryCompleted Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bCompleted = bCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.SetMainStoryCompleted
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCompleted                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::SetMainStoryCompleted(class UObject* WorldContextObject, bool bCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "SetMainStoryCompleted");

	Params::PhxProgressManager_SetMainStoryCompleted Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bCompleted = bCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.SetNewGamePlus
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsNGPlus                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::SetNewGamePlus(class UObject* WorldContextObject, bool bIsNGPlus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "SetNewGamePlus");

	Params::PhxProgressManager_SetNewGamePlus Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bIsNGPlus = bIsNGPlus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.SetStoryDLC
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsStoryDLC                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::SetStoryDLC(class UObject* WorldContextObject, bool bIsStoryDLC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "SetStoryDLC");

	Params::PhxProgressManager_SetStoryDLC Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bIsStoryDLC = bIsStoryDLC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.ShowCurrentObjectiveUINotification
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::ShowCurrentObjectiveUINotification(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "ShowCurrentObjectiveUINotification");

	Params::PhxProgressManager_ShowCurrentObjectiveUINotification Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.ShowSubObjective
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              SubObjectiveTag                                        (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeRemaining                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::ShowSubObjective(class UObject* WorldContextObject, const struct FGameplayTag& SubObjectiveTag, float TimeRemaining)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "ShowSubObjective");

	Params::PhxProgressManager_ShowSubObjective Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SubObjectiveTag = std::move(SubObjectiveTag);
	Parms.TimeRemaining = TimeRemaining;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.UpdateCurrentObjective
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              NewObjectiveTag                                        (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShowUINotification                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::UpdateCurrentObjective(class UObject* WorldContextObject, const struct FGameplayTag& NewObjectiveTag, bool bShowUINotification)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxProgressManager", "UpdateCurrentObjective");

	Params::PhxProgressManager_UpdateCurrentObjective Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.NewObjectiveTag = std::move(NewObjectiveTag);
	Parms.bShowUINotification = bShowUINotification;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.GivePlayerPendingItemsWithTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::GivePlayerPendingItemsWithTag(const struct FGameplayTag& Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProgressManager", "GivePlayerPendingItemsWithTag");

	Params::PhxProgressManager_GivePlayerPendingItemsWithTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProgressManager.TryRecordPlayerState
// (Final, Native, Private, HasOutParams, BlueprintCallable)
// Parameters:
// class APhxCharacter*                    PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bRecorded                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProgressManager::TryRecordPlayerState(class APhxCharacter* PlayerCharacter, bool* bRecorded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProgressManager", "TryRecordPlayerState");

	Params::PhxProgressManager_TryRecordPlayerState Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxProgressManager.HasPendingItemsWithTag
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxProgressManager::HasPendingItemsWithTag(const struct FGameplayTag& Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProgressManager", "HasPendingItemsWithTag");

	Params::PhxProgressManager_HasPendingItemsWithTag Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxProximityGlassBreakComponent.OnBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPhxProximityGlassBreakComponent::OnBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProximityGlassBreakComponent", "OnBeginOverlap");

	Params::PhxProximityGlassBreakComponent_OnBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProximityGlassBreakComponent.OnEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProximityGlassBreakComponent::OnEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProximityGlassBreakComponent", "OnEndOverlap");

	Params::PhxProximityGlassBreakComponent_OnEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProximityLightComponent.TurnOff
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Delay                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProximityLightComponent::TurnOff(float Delay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProximityLightComponent", "TurnOff");

	Params::PhxProximityLightComponent_TurnOff Parms{};

	Parms.Delay = Delay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxProximityLightComponent.TurnOn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Delay                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxProximityLightComponent::TurnOn(float Delay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxProximityLightComponent", "TurnOn");

	Params::PhxProximityLightComponent_TurnOn Parms{};

	Parms.Delay = Delay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxQteSystem.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxQteSystem*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxQteSystem* APhxQteSystem::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxQteSystem", "Get");

	Params::PhxQteSystem_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.DismissCurrentQte
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPhxQteDismissType                      DismissType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxQteSystem::DismissCurrentQte(EPhxQteDismissType DismissType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "DismissCurrentQte");

	Params::PhxQteSystem_DismissCurrentQte Parms{};

	Parms.DismissType = DismissType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxQteSystem.ForceFailCurrentQTE
// (Final, Native, Public, BlueprintCallable)

void APhxQteSystem::ForceFailCurrentQTE()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "ForceFailCurrentQTE");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxQteSystem.GetQteProgress
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxQteSystem::GetQteProgress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "GetQteProgress");

	Params::PhxQteSystem_GetQteProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.GetQteSubStateClass
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UState>               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UState> APhxQteSystem::GetQteSubStateClass()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "GetQteSubStateClass");

	Params::PhxQteSystem_GetQteSubStateClass Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.GetQteSubStateParams
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UQteStateParams*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UQteStateParams* APhxQteSystem::GetQteSubStateParams()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "GetQteSubStateParams");

	Params::PhxQteSystem_GetQteSubStateParams Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.OnButtonPromptSizeChanged
// (Final, Native, Private)
// Parameters:
// ESDSSize                                NewSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxQteSystem::OnButtonPromptSizeChanged(ESDSSize NewSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "OnButtonPromptSizeChanged");

	Params::PhxQteSystem_OnButtonPromptSizeChanged Parms{};

	Parms.NewSize = NewSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxQteSystem.QteBodyStateRequested
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxQteSystem::QteBodyStateRequested()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "QteBodyStateRequested");

	Params::PhxQteSystem_QteBodyStateRequested Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.RequestQte
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FQteRequest&               QteRequest                                             (Parm, NativeAccessSpecifierPublic)

void APhxQteSystem::RequestQte(const struct FQteRequest& QteRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "RequestQte");

	Params::PhxQteSystem_RequestQte Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxQteSystem.GetInputActionForActiveQte
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EQteInputAction                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EQteInputAction APhxQteSystem::GetInputActionForActiveQte() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "GetInputActionForActiveQte");

	Params::PhxQteSystem_GetInputActionForActiveQte Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.IsActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxQteSystem::IsActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "IsActive");

	Params::PhxQteSystem_IsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.IsAutoQteEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxQteSystem::IsAutoQteEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "IsAutoQteEnabled");

	Params::PhxQteSystem_IsAutoQteEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.IsRequestActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FQteRequest&               QteRequest                                             (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxQteSystem::IsRequestActive(const struct FQteRequest& QteRequest) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "IsRequestActive");

	Params::PhxQteSystem_IsRequestActive Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxQteSystem.IsUsingControllerActionForQte
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxQteSystem::IsUsingControllerActionForQte() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxQteSystem", "IsUsingControllerActionForQte");

	Params::PhxQteSystem_IsUsingControllerActionForQte Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.ApplyDiscount
// (Final, Native, Public)
// Parameters:
// EItemDataSubCategory                    ItemCategoryToDiscount                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DiscountPercentage                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxRiotModeLootProp_Weapon::ApplyDiscount(EItemDataSubCategory ItemCategoryToDiscount, float DiscountPercentage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "ApplyDiscount");

	Params::PhxRiotModeLootProp_Weapon_ApplyDiscount Parms{};

	Parms.ItemCategoryToDiscount = ItemCategoryToDiscount;
	Parms.DiscountPercentage = DiscountPercentage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.OnActorRestored
// (Final, Native, Private)

void APhxRiotModeLootProp_Weapon::OnActorRestored()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "OnActorRestored");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.OnTierChanged
// (Event, Public, BlueprintEvent)

void APhxRiotModeLootProp_Weapon::OnTierChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "OnTierChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.RefreshUI
// (Final, Native, Public, BlueprintCallable)

void APhxRiotModeLootProp_Weapon::RefreshUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "RefreshUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.SetItemTier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Tier                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxRiotModeLootProp_Weapon::SetItemTier(int32 Tier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "SetItemTier");

	Params::PhxRiotModeLootProp_Weapon_SetItemTier Parms{};

	Parms.Tier = Tier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.GetAllPurchasesDone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxRiotModeLootProp_Weapon::GetAllPurchasesDone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "GetAllPurchasesDone");

	Params::PhxRiotModeLootProp_Weapon_GetAllPurchasesDone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.GetItemClass
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class AEquippable>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class AEquippable> APhxRiotModeLootProp_Weapon::GetItemClass() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "GetItemClass");

	Params::PhxRiotModeLootProp_Weapon_GetItemClass Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.GetItemCost
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxRiotModeLootProp_Weapon::GetItemCost() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "GetItemCost");

	Params::PhxRiotModeLootProp_Weapon_GetItemCost Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.GetItemTier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxRiotModeLootProp_Weapon::GetItemTier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "GetItemTier");

	Params::PhxRiotModeLootProp_Weapon_GetItemTier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootProp_Weapon.GetMaxItemTier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APhxRiotModeLootProp_Weapon::GetMaxItemTier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootProp_Weapon", "GetMaxItemTier");

	Params::PhxRiotModeLootProp_Weapon_GetMaxItemTier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotModeLootPropManager.OnNewWeaponPurchasedFromCrate
// (Final, Native, Public)
// Parameters:
// TSubclassOf<class AEquippable>          OldWeapon                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AEquippable>          NewWeapon                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxRiotModeLootPropManager::OnNewWeaponPurchasedFromCrate(TSubclassOf<class AEquippable> OldWeapon, TSubclassOf<class AEquippable> NewWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotModeLootPropManager", "OnNewWeaponPurchasedFromCrate");

	Params::PhxRiotModeLootPropManager_OnNewWeaponPurchasedFromCrate Parms{};

	Parms.OldWeapon = OldWeapon;
	Parms.NewWeapon = NewWeapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSSimpleNotification.CloseNotification
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bDelayClose                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ElapsedTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSSimpleNotification::CloseNotification(bool bDelayClose, float ElapsedTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSSimpleNotification", "CloseNotification");

	Params::SDSSimpleNotification_CloseNotification Parms{};

	Parms.bDelayClose = bDelayClose;
	Parms.ElapsedTime = ElapsedTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSSimpleNotification.SetMessage
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSSimpleNotification::SetMessage(const class FText& InMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSSimpleNotification", "SetMessage");

	Params::SDSSimpleNotification_SetMessage Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSSimpleNotification.SetNotificationData
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FNotificationData&         InData                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSSimpleNotification::SetNotificationData(const struct FNotificationData& InData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSSimpleNotification", "SetNotificationData");

	Params::SDSSimpleNotification_SetNotificationData Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEProjectileGunWeapon.BP_OnPPEAccumulatedChargesChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   NewNumCharges                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEProjectileGunWeapon::BP_OnPPEAccumulatedChargesChanged(int32 NewNumCharges)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "BP_OnPPEAccumulatedChargesChanged");

	Params::PPEProjectileGunWeapon_BP_OnPPEAccumulatedChargesChanged Parms{};

	Parms.NewNumCharges = NewNumCharges;

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


// Function Phoenix.PPEProjectileGunWeapon.BP_OnPPESelectedActionChanged
// (Event, Protected, BlueprintEvent)

void APPEProjectileGunWeapon::BP_OnPPESelectedActionChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "BP_OnPPESelectedActionChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PPEProjectileGunWeapon.BP_OnRechargingChargesChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   NewNumCharges                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEProjectileGunWeapon::BP_OnRechargingChargesChanged(int32 NewNumCharges)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "BP_OnRechargingChargesChanged");

	Params::PPEProjectileGunWeapon_BP_OnRechargingChargesChanged Parms{};

	Parms.NewNumCharges = NewNumCharges;

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


// Function Phoenix.PPEProjectileGunWeapon.BP_UpdateNumChargesVisuals
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   NumCharges                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AlphaHighestCharge                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEProjectileGunWeapon::BP_UpdateNumChargesVisuals(int32 NumCharges, float AlphaHighestCharge)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "BP_UpdateNumChargesVisuals");

	Params::PPEProjectileGunWeapon_BP_UpdateNumChargesVisuals Parms{};

	Parms.NumCharges = NumCharges;
	Parms.AlphaHighestCharge = AlphaHighestCharge;

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


// Function Phoenix.PPEProjectileGunWeapon.LockProjectileTypes
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// uint8                                   TypesToLock                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEProjectileGunWeapon::LockProjectileTypes(uint8 TypesToLock)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "LockProjectileTypes");

	Params::PPEProjectileGunWeapon_LockProjectileTypes Parms{};

	Parms.TypesToLock = TypesToLock;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEProjectileGunWeapon.UnlockProjectileTypes
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// uint8                                   TypesToUnlock                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEProjectileGunWeapon::UnlockProjectileTypes(uint8 TypesToUnlock)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "UnlockProjectileTypes");

	Params::PPEProjectileGunWeapon_UnlockProjectileTypes Parms{};

	Parms.TypesToUnlock = TypesToUnlock;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEProjectileGunWeapon.UpdateHatchGlowEffects
// (Final, Native, Protected)
// Parameters:
// int32                                   NewNumCharges                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APPEProjectileGunWeapon::UpdateHatchGlowEffects(int32 NewNumCharges)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "UpdateHatchGlowEffects");

	Params::PPEProjectileGunWeapon_UpdateHatchGlowEffects Parms{};

	Parms.NewNumCharges = NewNumCharges;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEProjectileGunWeapon.GetChargeComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPPEChargeComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPPEChargeComponent* APPEProjectileGunWeapon::GetChargeComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "GetChargeComponent");

	Params::PPEProjectileGunWeapon_GetChargeComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PPEProjectileGunWeapon.GetUnlockedProjectileTypes
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APPEProjectileGunWeapon::GetUnlockedProjectileTypes() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEProjectileGunWeapon", "GetUnlockedProjectileTypes");

	Params::PPEProjectileGunWeapon_GetUnlockedProjectileTypes Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxRiotObjectiveMessage.UpdateDuration
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   InDuration                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxRiotObjectiveMessage::UpdateDuration(float InDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxRiotObjectiveMessage", "UpdateDuration");

	Params::PhxRiotObjectiveMessage_UpdateDuration Parms{};

	Parms.InDuration = InDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTraversalActor.OnBackInteractionExecuted
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxTraversalActor::OnBackInteractionExecuted(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalActor", "OnBackInteractionExecuted");

	Params::PhxTraversalActor_OnBackInteractionExecuted Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTraversalActor.OnFrontInteractionExecuted
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxTraversalActor::OnFrontInteractionExecuted(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalActor", "OnFrontInteractionExecuted");

	Params::PhxTraversalActor_OnFrontInteractionExecuted Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTraversalActor.ToggleInteraction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnableInteraction                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxTraversalActor::ToggleInteraction(bool bEnableInteraction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalActor", "ToggleInteraction");

	Params::PhxTraversalActor_ToggleInteraction Parms{};

	Parms.bEnableInteraction = bEnableInteraction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventBlueprintLibrary.QueueUpScriptedEventActionRequest
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APhxCharacterBase*                CharacterOwner                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UPhxScrEvtCharacterActionRequest>ActionRequestClass                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxScrEvtCharacterActionRequest* ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxScrEvtCharacterActionRequest* UPhxScriptedEventBlueprintLibrary::QueueUpScriptedEventActionRequest(class APhxCharacterBase* CharacterOwner, TSubclassOf<class UPhxScrEvtCharacterActionRequest> ActionRequestClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxScriptedEventBlueprintLibrary", "QueueUpScriptedEventActionRequest");

	Params::PhxScriptedEventBlueprintLibrary_QueueUpScriptedEventActionRequest Parms{};

	Parms.CharacterOwner = CharacterOwner;
	Parms.ActionRequestClass = ActionRequestClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxScriptedEventCharacterState.OnAnimMontageStarted
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxScriptedEventCharacterState::OnAnimMontageStarted(class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventCharacterState", "OnAnimMontageStarted");

	Params::PhxScriptedEventCharacterState_OnAnimMontageStarted Parms{};

	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventCharacterState.OnCancelQTE
// (Final, Native, Protected)
// Parameters:
// class FName                             InQteId                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxScriptedEventCharacterState::OnCancelQTE(class FName InQteId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventCharacterState", "OnCancelQTE");

	Params::PhxScriptedEventCharacterState_OnCancelQTE Parms{};

	Parms.InQteId = InQteId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxScriptedEventCharacterState.OnCompleteQTE
// (Final, Native, Protected)
// Parameters:
// class FName                             InQteId                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInResult                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxScriptedEventCharacterState::OnCompleteQTE(class FName InQteId, bool bInResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxScriptedEventCharacterState", "OnCompleteQTE");

	Params::PhxScriptedEventCharacterState_OnCompleteQTE Parms{};

	Parms.InQteId = InQteId;
	Parms.bInResult = bInResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTraversalSpline.RegisterAnimationPoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APhxTraversalSplinePoint_Animation*AnimationPoint                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldDeformSpline                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxTraversalSpline::RegisterAnimationPoint(class APhxTraversalSplinePoint_Animation* AnimationPoint, bool bShouldDeformSpline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalSpline", "RegisterAnimationPoint");

	Params::PhxTraversalSpline_RegisterAnimationPoint Parms{};

	Parms.AnimationPoint = AnimationPoint;
	Parms.bShouldDeformSpline = bShouldDeformSpline;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSearchLight.InitializeSearchLight
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UArrowComponent*                  InArrowComp                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTimelineComponent*               InSearchLightTimelineComp                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTimelineComponent*               InOverwriteLocationTargetTimelineComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTimelineComponent*               InFollowTimelineComp                                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSearchLight::InitializeSearchLight(class UArrowComponent* InArrowComp, class UTimelineComponent* InSearchLightTimelineComp, class UTimelineComponent* InOverwriteLocationTargetTimelineComp, class UTimelineComponent* InFollowTimelineComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSearchLight", "InitializeSearchLight");

	Params::PhxSearchLight_InitializeSearchLight Parms{};

	Parms.InArrowComp = InArrowComp;
	Parms.InSearchLightTimelineComp = InSearchLightTimelineComp;
	Parms.InOverwriteLocationTargetTimelineComp = InOverwriteLocationTargetTimelineComp;
	Parms.InFollowTimelineComp = InFollowTimelineComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSearchLight.SetSearchLightFollowActor
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSearchLight::SetSearchLightFollowActor(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSearchLight", "SetSearchLightFollowActor");

	Params::PhxSearchLight_SetSearchLightFollowActor Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSearchLight.SetSearchLightOverwriteActor
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSearchLight::SetSearchLightOverwriteActor(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSearchLight", "SetSearchLightOverwriteActor");

	Params::PhxSearchLight_SetSearchLightOverwriteActor Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSearchLight.SetSearchLightTargetActor
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSearchLight::SetSearchLightTargetActor(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSearchLight", "SetSearchLightTargetActor");

	Params::PhxSearchLight_SetSearchLightTargetActor Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSearchLight.UpdateFollowTimelineFunc
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   OutputAlpha                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSearchLight::UpdateFollowTimelineFunc(float OutputAlpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSearchLight", "UpdateFollowTimelineFunc");

	Params::PhxSearchLight_UpdateFollowTimelineFunc Parms{};

	Parms.OutputAlpha = OutputAlpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSearchLight.UpdateOverwriteLocationTargetTimelineFunc
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   OutputAlpha                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSearchLight::UpdateOverwriteLocationTargetTimelineFunc(float OutputAlpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSearchLight", "UpdateOverwriteLocationTargetTimelineFunc");

	Params::PhxSearchLight_UpdateOverwriteLocationTargetTimelineFunc Parms{};

	Parms.OutputAlpha = OutputAlpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSearchLight.UpdateSearchLightTimelineFunc
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   OutputAlpha                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSearchLight::UpdateSearchLightTimelineFunc(float OutputAlpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSearchLight", "UpdateSearchLightTimelineFunc");

	Params::PhxSearchLight_UpdateSearchLightTimelineFunc Parms{};

	Parms.OutputAlpha = OutputAlpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSendPlayerDeathTelemetry.SendPlayerDeathTelemetry
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxPlayerCharacter*              PlayerCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DamageAmount                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSendPlayerDeathTelemetry*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSendPlayerDeathTelemetry* UPhxSendPlayerDeathTelemetry::SendPlayerDeathTelemetry(class UObject* WorldContextObject, class APhxPlayerCharacter* PlayerCharacter, float DamageAmount, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSendPlayerDeathTelemetry", "SendPlayerDeathTelemetry");

	Params::PhxSendPlayerDeathTelemetry_SendPlayerDeathTelemetry Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerCharacter = PlayerCharacter;
	Parms.DamageAmount = DamageAmount;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSimpleElevator.DisableElevatorStartInteractable
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void APhxSimpleElevator::DisableElevatorStartInteractable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "DisableElevatorStartInteractable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleElevator.EnableElevatorStartInteractable
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void APhxSimpleElevator::EnableElevatorStartInteractable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "EnableElevatorStartInteractable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleElevator.OnBottomFloorPanelInteract
// (Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSimpleElevator::OnBottomFloorPanelInteract(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "OnBottomFloorPanelInteract");

	Params::PhxSimpleElevator_OnBottomFloorPanelInteract Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleElevator.OnElevatorStartInteract
// (Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSimpleElevator::OnElevatorStartInteract(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "OnElevatorStartInteract");

	Params::PhxSimpleElevator_OnElevatorStartInteract Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleElevator.OnPrimaryGateAnimationFinished
// (Final, Native, Protected)

void APhxSimpleElevator::OnPrimaryGateAnimationFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "OnPrimaryGateAnimationFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleElevator.OnSecondaryGateAnimationFinished
// (Final, Native, Protected)

void APhxSimpleElevator::OnSecondaryGateAnimationFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "OnSecondaryGateAnimationFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleElevator.OnTopFloorPanelInteract
// (Native, Protected)
// Parameters:
// class APhxCharacter*                    InteractedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSimpleElevator::OnTopFloorPanelInteract(class APhxCharacter* InteractedBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "OnTopFloorPanelInteract");

	Params::PhxSimpleElevator_OnTopFloorPanelInteract Parms{};

	Parms.InteractedBy = InteractedBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSimpleElevator.GetElevatorSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxSimpleElevator::GetElevatorSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "GetElevatorSpeed");

	Params::PhxSimpleElevator_GetElevatorSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSimpleElevator.GetElevatorStartInteractable
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UInteractableComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInteractableComponent* APhxSimpleElevator::GetElevatorStartInteractable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSimpleElevator", "GetElevatorStartInteractable");

	Params::PhxSimpleElevator_GetElevatorStartInteractable Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSkinnableCharacterInterface.GetSkinnableCharacterTag
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayTag IPhxSkinnableCharacterInterface::GetSkinnableCharacterTag() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxSkinnableCharacterInterface", "GetSkinnableCharacterTag");

	Params::PhxSkinnableCharacterInterface_GetSkinnableCharacterTag Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSkinnableCharacterInterface.GetSkinnableMainMesh
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* IPhxSkinnableCharacterInterface::GetSkinnableMainMesh() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxSkinnableCharacterInterface", "GetSkinnableMainMesh");

	Params::PhxSkinnableCharacterInterface_GetSkinnableMainMesh Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSkinnableCharacterInterface.IsSkinnablePlayer
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IPhxSkinnableCharacterInterface::IsSkinnablePlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PhxSkinnableCharacterInterface", "IsSkinnablePlayer");

	Params::PhxSkinnableCharacterInterface_IsSkinnablePlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSnowcat.OnDisembarkScriptedEventFinish
// (Final, Native, Protected)

void APhxSnowcat::OnDisembarkScriptedEventFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "OnDisembarkScriptedEventFinish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSnowcat.OnDisembarkScriptedEventStart
// (Final, Native, Protected)

void APhxSnowcat::OnDisembarkScriptedEventStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "OnDisembarkScriptedEventStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSnowcat.OnEmbarkScriptedEventFinish
// (Final, Native, Protected)

void APhxSnowcat::OnEmbarkScriptedEventFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "OnEmbarkScriptedEventFinish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSnowcat.OnEmbarkScriptedEventStart
// (Final, Native, Protected)

void APhxSnowcat::OnEmbarkScriptedEventStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "OnEmbarkScriptedEventStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSnowcat.SetDriverDoorOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bDoorOpen                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSnowcat::SetDriverDoorOpen(bool bDoorOpen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "SetDriverDoorOpen");

	Params::PhxSnowcat_SetDriverDoorOpen Parms{};

	Parms.bDoorOpen = bDoorOpen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSnowcat.SetWindshieldWipersActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSnowcat::SetWindshieldWipersActive(bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "SetWindshieldWipersActive");

	Params::PhxSnowcat_SetWindshieldWipersActive Parms{};

	Parms.bActive = bActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSnowcat.UpdateDashboardUISpeed
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   CurrentSpeed                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSnowcat::UpdateDashboardUISpeed(float CurrentSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "UpdateDashboardUISpeed");

	Params::PhxSnowcat_UpdateDashboardUISpeed Parms{};

	Parms.CurrentSpeed = CurrentSpeed;

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


// Function Phoenix.PhxSnowcat.UpdateDashboardUITurnStrength
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   TurnStrength                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxSnowcat::UpdateDashboardUITurnStrength(float TurnStrength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "UpdateDashboardUITurnStrength");

	Params::PhxSnowcat_UpdateDashboardUITurnStrength Parms{};

	Parms.TurnStrength = TurnStrength;

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


// Function Phoenix.PhxSnowcat.GetDriverAttachComponent
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* APhxSnowcat::GetDriverAttachComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "GetDriverAttachComponent");

	Params::PhxSnowcat_GetDriverAttachComponent Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSnowcat.GetPassengerAttachComponent
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* APhxSnowcat::GetPassengerAttachComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSnowcat", "GetPassengerAttachComponent");

	Params::PhxSnowcat_GetPassengerAttachComponent Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Phoenix.SDSPromptWidgetProgress.SetProgress
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSPromptWidgetProgress::SetProgress(float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSPromptWidgetProgress", "SetProgress");

	Params::SDSPromptWidgetProgress_SetProgress Parms{};

	Parms.InValue = InValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.BodyfallGeneralSound
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketBeginOffset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketEndOffset                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HalfHeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkComponent* UPhxSoundAnimNotifyLibrary::BodyfallGeneralSound(class USkeletalMeshComponent* MeshComponent, const class FString& AttachName, const struct FVector& SocketBeginOffset, const struct FVector& SocketEndOffset, float Radius, float HalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "BodyfallGeneralSound");

	Params::PhxSoundAnimNotifyLibrary_BodyfallGeneralSound Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.SocketBeginOffset = std::move(SocketBeginOffset);
	Parms.SocketEndOffset = std::move(SocketEndOffset);
	Parms.Radius = Radius;
	Parms.HalfHeight = HalfHeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.BodyfallMaterialCheck
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USceneComponent*                  MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketBeginOffset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketEndOffset                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HalfHeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSoundAnimNotifyLibrary::BodyfallMaterialCheck(class USceneComponent* MeshComponent, const class FString& AttachName, struct FHitResult* OutHit, const struct FVector& SocketBeginOffset, const struct FVector& SocketEndOffset, float Radius, float HalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "BodyfallMaterialCheck");

	Params::PhxSoundAnimNotifyLibrary_BodyfallMaterialCheck Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.SocketBeginOffset = std::move(SocketBeginOffset);
	Parms.SocketEndOffset = std::move(SocketEndOffset);
	Parms.Radius = Radius;
	Parms.HalfHeight = HalfHeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.BodyfallSkelCheckSound
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent**                    AkComponent                                            (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketBeginOffset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketEndOffset                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HalfHeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSoundAnimNotifyLibrary::BodyfallSkelCheckSound(class USkeletalMeshComponent* MeshComponent, const class FString& AttachName, class UAkComponent** AkComponent, const struct FVector& SocketBeginOffset, const struct FVector& SocketEndOffset, float Radius, float HalfHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "BodyfallSkelCheckSound");

	Params::PhxSoundAnimNotifyLibrary_BodyfallSkelCheckSound Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.SocketBeginOffset = std::move(SocketBeginOffset);
	Parms.SocketEndOffset = std::move(SocketEndOffset);
	Parms.Radius = Radius;
	Parms.HalfHeight = HalfHeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultBodyfallMaterial
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxSoundAnimNotifyLibrary::DefaultBodyfallMaterial(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "DefaultBodyfallMaterial");

	Params::PhxSoundAnimNotifyLibrary_DefaultBodyfallMaterial Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultFootstepMaterialName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxSoundAnimNotifyLibrary::DefaultFootstepMaterialName(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "DefaultFootstepMaterialName");

	Params::PhxSoundAnimNotifyLibrary_DefaultFootstepMaterialName Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultGruntSkeleton
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxSoundAnimNotifyLibrary::DefaultGruntSkeleton(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "DefaultGruntSkeleton");

	Params::PhxSoundAnimNotifyLibrary_DefaultGruntSkeleton Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.DefaultPhysicalMaterial
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPhxSoundAnimNotifyLibrary::DefaultPhysicalMaterial(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "DefaultPhysicalMaterial");

	Params::PhxSoundAnimNotifyLibrary_DefaultPhysicalMaterial Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepMaterialCheck
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USceneComponent*                  MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   BeginOffset                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndOffset                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HalfSize                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSoundAnimNotifyLibrary::FootstepMaterialCheck(class USceneComponent* MeshComponent, const class FString& AttachName, struct FHitResult* OutHit, const struct FVector& BeginOffset, const struct FVector& EndOffset, const struct FVector& HalfSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "FootstepMaterialCheck");

	Params::PhxSoundAnimNotifyLibrary_FootstepMaterialCheck Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.BeginOffset = std::move(BeginOffset);
	Parms.EndOffset = std::move(EndOffset);
	Parms.HalfSize = std::move(HalfSize);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepMaterialCheckRusher
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USceneComponent*                  SceneComponent                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketBeginOffset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketEndOffset                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSoundAnimNotifyLibrary::FootstepMaterialCheckRusher(class USceneComponent* SceneComponent, const class FString& AttachName, struct FHitResult* OutHit, const struct FVector& SocketBeginOffset, const struct FVector& SocketEndOffset, float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "FootstepMaterialCheckRusher");

	Params::PhxSoundAnimNotifyLibrary_FootstepMaterialCheckRusher Parms{};

	Parms.SceneComponent = SceneComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.SocketBeginOffset = std::move(SocketBeginOffset);
	Parms.SocketEndOffset = std::move(SocketEndOffset);
	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepSimple
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkSwitchValue*                   SwitchValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketBeginOffset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketEndOffset                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketHalfSize                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent**                    AkObject                                               (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSoundAnimNotifyLibrary::FootstepSimple(class USkeletalMeshComponent* MeshComponent, const class FString& AttachName, class UAkSwitchValue* SwitchValue, const struct FVector& SocketBeginOffset, const struct FVector& SocketEndOffset, const struct FVector& SocketHalfSize, class UAkComponent** AkObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "FootstepSimple");

	Params::PhxSoundAnimNotifyLibrary_FootstepSimple Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.SwitchValue = SwitchValue;
	Parms.SocketBeginOffset = std::move(SocketBeginOffset);
	Parms.SocketEndOffset = std::move(SocketEndOffset);
	Parms.SocketHalfSize = std::move(SocketHalfSize);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Phoenix.PhxSoundAnimNotifyLibrary.FootstepSimpleRusher
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkSwitchValue*                   FootSwitch                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BeginOffset                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndOffset                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UAkComponent*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkComponent* UPhxSoundAnimNotifyLibrary::FootstepSimpleRusher(class USkeletalMeshComponent* MeshComponent, const class FString& AttachName, class UAkSwitchValue* FootSwitch, const struct FVector& BeginOffset, const struct FVector& EndOffset, float Radius, struct FHitResult* OutHit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "FootstepSimpleRusher");

	Params::PhxSoundAnimNotifyLibrary_FootstepSimpleRusher Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.FootSwitch = FootSwitch;
	Parms.BeginOffset = std::move(BeginOffset);
	Parms.EndOffset = std::move(EndOffset);
	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.HandPatSkeletonCheckSound
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent**                    SoundComponent                                         (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    DefaultHandsSwitchGroup                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketBeginOffset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SocketEndOffset                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSoundAnimNotifyLibrary::HandPatSkeletonCheckSound(class USkeletalMeshComponent* MeshComponent, const class FString& AttachName, class UAkComponent** SoundComponent, const class FString& DefaultHandsSwitchGroup, const struct FVector& SocketBeginOffset, const struct FVector& SocketEndOffset, float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "HandPatSkeletonCheckSound");

	Params::PhxSoundAnimNotifyLibrary_HandPatSkeletonCheckSound Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.DefaultHandsSwitchGroup = std::move(DefaultHandsSwitchGroup);
	Parms.SocketBeginOffset = std::move(SocketBeginOffset);
	Parms.SocketEndOffset = std::move(SocketEndOffset);
	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.MovementSkeletonCheckSound
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkSwitchValue*                   SwitchValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    TargetSkeletonName                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent**                    SoundComponent                                         (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxSoundAnimNotifyLibrary::MovementSkeletonCheckSound(class USkeletalMeshComponent* MeshComponent, const class FString& AttachName, class UAkSwitchValue* SwitchValue, const class FString& TargetSkeletonName, class UAkComponent** SoundComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "MovementSkeletonCheckSound");

	Params::PhxSoundAnimNotifyLibrary_MovementSkeletonCheckSound Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.SwitchValue = SwitchValue;
	Parms.TargetSkeletonName = std::move(TargetSkeletonName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.PickupMaterialCheckSound
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttachName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSoundAnimNotifyLibrary::PickupMaterialCheckSound(class USkeletalMeshComponent* MeshComponent, const class FString& AttachName, float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "PickupMaterialCheckSound");

	Params::PhxSoundAnimNotifyLibrary_PickupMaterialCheckSound Parms{};

	Parms.MeshComponent = MeshComponent;
	Parms.AttachName = std::move(AttachName);
	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.SetFootstepMaterialSwitch
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAkComponent*                     AkComponent                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PhysMaterialName                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSoundAnimNotifyLibrary::SetFootstepMaterialSwitch(class UAkComponent* AkComponent, const class FString& PhysMaterialName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "SetFootstepMaterialSwitch");

	Params::PhxSoundAnimNotifyLibrary_SetFootstepMaterialSwitch Parms{};

	Parms.AkComponent = AkComponent;
	Parms.PhysMaterialName = std::move(PhysMaterialName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSoundAnimNotifyLibrary.SkeletonCheck
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class USkinnedMeshComponent*      SkinnedMesh                                            (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   PlayerGruntBareLeftBootRight                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   GruntBareLeftBareRight                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   GruntBootLeftBootRight                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   Grunt                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSoundAnimNotifyLibrary::SkeletonCheck(const class USkinnedMeshComponent* SkinnedMesh, bool* PlayerGruntBareLeftBootRight, bool* GruntBareLeftBareRight, bool* GruntBootLeftBootRight, bool* Grunt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSoundAnimNotifyLibrary", "SkeletonCheck");

	Params::PhxSoundAnimNotifyLibrary_SkeletonCheck Parms{};

	Parms.SkinnedMesh = SkinnedMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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

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


// Function Phoenix.PhxSoundComponent.OnSACompAddedDestroyed
// (Final, Native, Public)

void UPhxSoundComponent::OnSACompAddedDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "OnSACompAddedDestroyed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSoundComponent.PhxSetSwitch
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    WorkUnitString                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SwitchGroupString                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SwitchValue                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSoundComponent::PhxSetSwitch(const class FString& WorkUnitString, const class FString& SwitchGroupString, const class FString& SwitchValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "PhxSetSwitch");

	Params::PhxSoundComponent_PhxSetSwitch Parms{};

	Parms.WorkUnitString = std::move(WorkUnitString);
	Parms.SwitchGroupString = std::move(SwitchGroupString);
	Parms.SwitchValue = std::move(SwitchValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSoundComponent.PostForcedSoundEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    AkEvent                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxSoundComponent::PostForcedSoundEvent(class UAkAudioEvent* AkEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "PostForcedSoundEvent");

	Params::PhxSoundComponent_PostForcedSoundEvent Parms{};

	Parms.AkEvent = AkEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundComponent.PostForcedSoundEventWithCallbackLocal
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStopOnDestroy                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CallbackMask                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)>&PostEventCallback                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxSoundComponent::PostForcedSoundEventWithCallbackLocal(class UAkAudioEvent* Event, bool bStopOnDestroy, int32 CallbackMask, const TDelegate<void(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)>& PostEventCallback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "PostForcedSoundEventWithCallbackLocal");

	Params::PhxSoundComponent_PostForcedSoundEventWithCallbackLocal Parms{};

	Parms.Event = Event;
	Parms.bStopOnDestroy = bStopOnDestroy;
	Parms.CallbackMask = CallbackMask;
	Parms.PostEventCallback = PostEventCallback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundComponent.PostSoundEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    AkEvent                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxSoundComponent::PostSoundEvent(class UAkAudioEvent* AkEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "PostSoundEvent");

	Params::PhxSoundComponent_PostSoundEvent Parms{};

	Parms.AkEvent = AkEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundComponent.PostSoundEventWithCallbackLocal
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStopOnDestroy                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CallbackMask                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)>&PostEventCallback                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxSoundComponent::PostSoundEventWithCallbackLocal(class UAkAudioEvent* Event, bool bStopOnDestroy, int32 CallbackMask, const TDelegate<void(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)>& PostEventCallback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "PostSoundEventWithCallbackLocal");

	Params::PhxSoundComponent_PostSoundEventWithCallbackLocal Parms{};

	Parms.Event = Event;
	Parms.bStopOnDestroy = bStopOnDestroy;
	Parms.CallbackMask = CallbackMask;
	Parms.PostEventCallback = PostEventCallback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSoundComponent.StopSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   PlayingSoundId                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSoundComponent::StopSound(int32 PlayingSoundId, float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "StopSound");

	Params::PhxSoundComponent_StopSound Parms{};

	Parms.PlayingSoundId = PlayingSoundId;
	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSoundComponent.GetLastPostedSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxSoundComponent::GetLastPostedSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSoundComponent", "GetLastPostedSound");

	Params::PhxSoundComponent_GetLastPostedSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ServerButtonProxy.OnClicked
// (Final, Native, Public)

void UServerButtonProxy::OnClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ServerButtonProxy", "OnClicked");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2.GetPlayerWalksAwayFromMachineSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetPlayerWalksAwayFromMachineSound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetPlayerWalksAwayFromMachineSound");

	Params::PrinterV2_GetPlayerWalksAwayFromMachineSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.Print
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FItemData&                 ItemData                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   NumOfStacks                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APrinterV2::Print(const struct FItemData& ItemData, int32 NumOfStacks)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "Print");

	Params::PrinterV2_Print Parms{};

	Parms.ItemData = std::move(ItemData);
	Parms.NumOfStacks = NumOfStacks;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2.PrinterStateChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// class UState*                           Sender                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UState*                           LastState                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UState*                           NextState                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APrinterV2::PrinterStateChanged(class UState* Sender, class UState* LastState, class UState* NextState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "PrinterStateChanged");

	Params::PrinterV2_PrinterStateChanged Parms{};

	Parms.Sender = Sender;
	Parms.LastState = LastState;
	Parms.NextState = NextState;

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


// Function Phoenix.PrinterV2.SetBuyUIVisibility
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APrinterV2::SetBuyUIVisibility(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "SetBuyUIVisibility");

	Params::PrinterV2_SetBuyUIVisibility Parms{};

	Parms.bVisible = bVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2.Upgrade
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEquippable*                      ItemToUpgrade                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxCraftingRecipe*         InRecipe                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APrinterV2::Upgrade(class AEquippable* ItemToUpgrade, const class UPhxCraftingRecipe* InRecipe)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "Upgrade");

	Params::PrinterV2_Upgrade Parms{};

	Parms.ItemToUpgrade = ItemToUpgrade;
	Parms.InRecipe = InRecipe;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2.CalculatePriceWithDiscount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   BasePrice                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APrinterV2::CalculatePriceWithDiscount(int32 BasePrice) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "CalculatePriceWithDiscount");

	Params::PrinterV2_CalculatePriceWithDiscount Parms{};

	Parms.BasePrice = BasePrice;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetDiscount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APrinterV2::GetDiscount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetDiscount");

	Params::PrinterV2_GetDiscount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetPlayerApproachesMachineSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetPlayerApproachesMachineSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetPlayerApproachesMachineSound");

	Params::PrinterV2_GetPlayerApproachesMachineSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetSoundComp
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxSoundComponent*               ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSoundComponent* APrinterV2::GetSoundComp() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetSoundComp");

	Params::PrinterV2_GetSoundComp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetUICancelSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetUICancelSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetUICancelSound");

	Params::PrinterV2_GetUICancelSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetUIConfirmSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetUIConfirmSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetUIConfirmSound");

	Params::PrinterV2_GetUIConfirmSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetUIErrorSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetUIErrorSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetUIErrorSound");

	Params::PrinterV2_GetUIErrorSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetUISweepDownSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetUISweepDownSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetUISweepDownSound");

	Params::PrinterV2_GetUISweepDownSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetUISweepLeftSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetUISweepLeftSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetUISweepLeftSound");

	Params::PrinterV2_GetUISweepLeftSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetUISweepRightSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetUISweepRightSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetUISweepRightSound");

	Params::PrinterV2_GetUISweepRightSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.GetUISweepUpSound
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* APrinterV2::GetUISweepUpSound() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "GetUISweepUpSound");

	Params::PrinterV2_GetUISweepUpSound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrinterV2.IsReadyForUsage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APrinterV2::IsReadyForUsage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2", "IsReadyForUsage");

	Params::PrinterV2_IsReadyForUsage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSplineComponent.AddNewModifier
// (Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UPhxSplineModifier>   ModifierClass                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSplineModifier*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSplineModifier* UPhxSplineComponent::AddNewModifier(TSubclassOf<class UPhxSplineModifier> ModifierClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSplineComponent", "AddNewModifier");

	Params::PhxSplineComponent_AddNewModifier Parms{};

	Parms.ModifierClass = ModifierClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSplineComponent.RemoveModifier
// (Native, Public, BlueprintCallable)
// Parameters:
// class UPhxSplineModifier*               ModifierToRemove                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxSplineComponent::RemoveModifier(class UPhxSplineModifier* ModifierToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxSplineComponent", "RemoveModifier");

	Params::PhxSplineComponent_RemoveModifier Parms{};

	Parms.ModifierToRemove = ModifierToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxSplineUtil.ApproximateNearestDistanceAlongSpline
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class USplineComponent*           Spline                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             recursionDepth                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxSplineUtil::ApproximateNearestDistanceAlongSpline(const class USplineComponent* Spline, const struct FVector& WorldLocation, const int32 recursionDepth)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSplineUtil", "ApproximateNearestDistanceAlongSpline");

	Params::PhxSplineUtil_ApproximateNearestDistanceAlongSpline Parms{};

	Parms.Spline = Spline;
	Parms.WorldLocation = std::move(WorldLocation);
	Parms.recursionDepth = recursionDepth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSplineUtil.ApproximateNearestLocationAlongSpline
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class USplineComponent*           Spline                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPhxSplineUtil::ApproximateNearestLocationAlongSpline(const class USplineComponent* Spline, const struct FVector& WorldLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSplineUtil", "ApproximateNearestLocationAlongSpline");

	Params::PhxSplineUtil_ApproximateNearestLocationAlongSpline Parms{};

	Parms.Spline = Spline;
	Parms.WorldLocation = std::move(WorldLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSplineUtil.ApproximateNearestLocationToActorAlongSpline
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class USplineComponent*           Spline                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         actorToSpline                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPhxSplineUtil::ApproximateNearestLocationToActorAlongSpline(const class USplineComponent* Spline, const class AActor* Actor, struct FVector* actorToSpline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSplineUtil", "ApproximateNearestLocationToActorAlongSpline");

	Params::PhxSplineUtil_ApproximateNearestLocationToActorAlongSpline Parms{};

	Parms.Spline = Spline;
	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxSplineUtil.ApproximateNearestLocationToComponentAlongSpline
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class USplineComponent*           Spline                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USceneComponent*            Component                                              (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         componentToSpline                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPhxSplineUtil::ApproximateNearestLocationToComponentAlongSpline(const class USplineComponent* Spline, const class USceneComponent* Component, struct FVector* componentToSpline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxSplineUtil", "ApproximateNearestLocationToComponentAlongSpline");

	Params::PhxSplineUtil_ApproximateNearestLocationToComponentAlongSpline Parms{};

	Parms.Spline = Spline;
	Parms.Component = Component;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Phoenix.PhxStompableComponent.IncreaseStompCount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxStompableComponent::IncreaseStompCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxStompableComponent", "IncreaseStompCount");

	Params::PhxStompableComponent_IncreaseStompCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxStompableComponent.SetCanTakeStompDamage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bCanBeDamaged                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxStompableComponent::SetCanTakeStompDamage(bool bCanBeDamaged)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxStompableComponent", "SetCanTakeStompDamage");

	Params::PhxStompableComponent_SetCanTakeStompDamage Parms{};

	Parms.bCanBeDamaged = bCanBeDamaged;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxStompableComponent.CanTakeStompDamage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxStompableComponent::CanTakeStompDamage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxStompableComponent", "CanTakeStompDamage");

	Params::PhxStompableComponent_CanTakeStompDamage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxStompableComponent.GetStompCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhxStompableComponent::GetStompCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxStompableComponent", "GetStompCount");

	Params::PhxStompableComponent_GetStompCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTelemetryManager.Get
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxTelemetryManager*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxTelemetryManager* UPhxTelemetryManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxTelemetryManager", "Get");

	Params::PhxTelemetryManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTelemetryManager.SendFinishGameTelemetry
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::SendFinishGameTelemetry(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxTelemetryManager", "SendFinishGameTelemetry");

	Params::PhxTelemetryManager_SendFinishGameTelemetry Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnCheckpointRecorded
// (Final, Native, Protected)
// Parameters:
// class ACheckpoint*                      RecordedCheckpoint                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnCheckpointRecorded(class ACheckpoint* RecordedCheckpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnCheckpointRecorded");

	Params::PhxTelemetryManager_OnCheckpointRecorded Parms{};

	Parms.RecordedCheckpoint = RecordedCheckpoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnDefensiveAction
// (Final, Native, Protected, HasOutParams)
// Parameters:
// EReactionType                           ReactionType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDefensiveReactDirection                ReactionDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnDefensiveAction(EReactionType ReactionType, EDefensiveReactDirection ReactionDir, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnDefensiveAction");

	Params::PhxTelemetryManager_OnDefensiveAction Parms{};

	Parms.ReactionType = ReactionType;
	Parms.ReactionDir = ReactionDir;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnEnemyDeath
// (Final, Native, Protected)
// Parameters:
// class UPhxAIGameStateManager*           GameStateManager                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxAICharacter*                  Enemy                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnEnemyDeath(class UPhxAIGameStateManager* GameStateManager, class APhxAICharacter* Enemy, class AController* KillerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnEnemyDeath");

	Params::PhxTelemetryManager_OnEnemyDeath Parms{};

	Parms.GameStateManager = GameStateManager;
	Parms.Enemy = Enemy;
	Parms.KillerController = KillerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnEnterSpace
// (Final, Native, Protected)
// Parameters:
// const class APhxLevelPacingMeterSpace*  Space                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnEnterSpace(const class APhxLevelPacingMeterSpace* Space)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnEnterSpace");

	Params::PhxTelemetryManager_OnEnterSpace Parms{};

	Parms.Space = Space;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnExitSpace
// (Final, Native, Protected)
// Parameters:
// const class APhxLevelPacingMeterSpace*  Space                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeSpentInSpace                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnExitSpace(const class APhxLevelPacingMeterSpace* Space, float TimeSpentInSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnExitSpace");

	Params::PhxTelemetryManager_OnExitSpace Parms{};

	Parms.Space = Space;
	Parms.TimeSpentInSpace = TimeSpentInSpace;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnHitRecorded
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UPhxCharacterHealthComponent*HealthComponent                                        (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitRecord&                HitRecord                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnHitRecorded(class APhxCharacter* Character, const class UPhxCharacterHealthComponent* HealthComponent, const struct FHitRecord& HitRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnHitRecorded");

	Params::PhxTelemetryManager_OnHitRecorded Parms{};

	Parms.Character = Character;
	Parms.HealthComponent = HealthComponent;
	Parms.HitRecord = std::move(HitRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnMapEndLoad
// (Final, Native, Protected)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnMapEndLoad(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnMapEndLoad");

	Params::PhxTelemetryManager_OnMapEndLoad Parms{};

	Parms.World = World;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnMapStartLoad
// (Final, Native, Protected)
// Parameters:
// const class FString&                    MapPath                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnMapStartLoad(const class FString& MapPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnMapStartLoad");

	Params::PhxTelemetryManager_OnMapStartLoad Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnMeleeAttack
// (Final, Native, Protected)
// Parameters:
// const class UMeleeAttackState*          MeleeAttackState                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APhxCharacter*              SourceCharacter                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APhxCharacter*              TargetCharacter                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnMeleeAttack(const class UMeleeAttackState* MeleeAttackState, const class APhxCharacter* SourceCharacter, const class APhxCharacter* TargetCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnMeleeAttack");

	Params::PhxTelemetryManager_OnMeleeAttack Parms{};

	Parms.MeleeAttackState = MeleeAttackState;
	Parms.SourceCharacter = SourceCharacter;
	Parms.TargetCharacter = TargetCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnPlayerDeath
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    DeadCharacter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KillingBlowHealthDelta                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnPlayerDeath(class APhxCharacter* DeadCharacter, class AActor* KillerActor, class AController* KillerController, float KillingBlowHealthDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnPlayerDeath");

	Params::PhxTelemetryManager_OnPlayerDeath Parms{};

	Parms.DeadCharacter = DeadCharacter;
	Parms.KillerActor = KillerActor;
	Parms.KillerController = KillerController;
	Parms.KillingBlowHealthDelta = KillingBlowHealthDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnPrinterInteract
// (Final, Native, Protected)
// Parameters:
// class AActor*                           PrinterActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnPrinterInteract(class AActor* PrinterActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnPrinterInteract");

	Params::PhxTelemetryManager_OnPrinterInteract Parms{};

	Parms.PrinterActor = PrinterActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnPrinterPrinted
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           PrinterActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   QuantityPerItem                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TotalQuantity                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ItemStacks                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CostPerItem                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TotalCost                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnPrinterPrinted(class AActor* PrinterActor, const class FName& ItemName, int32 QuantityPerItem, int32 TotalQuantity, int32 ItemStacks, int32 CostPerItem, int32 TotalCost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnPrinterPrinted");

	Params::PhxTelemetryManager_OnPrinterPrinted Parms{};

	Parms.PrinterActor = PrinterActor;
	Parms.ItemName = ItemName;
	Parms.QuantityPerItem = QuantityPerItem;
	Parms.TotalQuantity = TotalQuantity;
	Parms.ItemStacks = ItemStacks;
	Parms.CostPerItem = CostPerItem;
	Parms.TotalCost = TotalCost;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnPrinterUpgraded
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           PrinterActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      ItemName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      RecipeName                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnPrinterUpgraded(class AActor* PrinterActor, const class FName& ItemName, const class FText& RecipeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnPrinterUpgraded");

	Params::PhxTelemetryManager_OnPrinterUpgraded Parms{};

	Parms.PrinterActor = PrinterActor;
	Parms.ItemName = ItemName;
	Parms.RecipeName = std::move(RecipeName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnProductInStoreClosed
// (Final, Native, Protected)
// Parameters:
// const class FString&                    ProductId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPurchased                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnProductInStoreClosed(const class FString& ProductId, bool bPurchased)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnProductInStoreClosed");

	Params::PhxTelemetryManager_OnProductInStoreClosed Parms{};

	Parms.ProductId = std::move(ProductId);
	Parms.bPurchased = bPurchased;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnProductInStoreOpened
// (Final, Native, Protected)
// Parameters:
// const class FString&                    ProductId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnProductInStoreOpened(const class FString& ProductId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnProductInStoreOpened");

	Params::PhxTelemetryManager_OnProductInStoreOpened Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnRangeAttack
// (Final, Native, Protected)
// Parameters:
// const class APhxProjectile*             Projectile                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APhxCharacter*              SourceCharacter                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APhxCharacter*              TargetCharacter                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnRangeAttack(const class APhxProjectile* Projectile, const class APhxCharacter* SourceCharacter, const class APhxCharacter* TargetCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnRangeAttack");

	Params::PhxTelemetryManager_OnRangeAttack Parms{};

	Parms.Projectile = Projectile;
	Parms.SourceCharacter = SourceCharacter;
	Parms.TargetCharacter = TargetCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnReceiverSwapped
// (Final, Native, Protected)
// Parameters:
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxRangedWeapon*                 PreviousWeapon                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxRangedWeapon*                 NewWeapon                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnReceiverSwapped(class APhxCharacter* Character, class APhxRangedWeapon* PreviousWeapon, class APhxRangedWeapon* NewWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnReceiverSwapped");

	Params::PhxTelemetryManager_OnReceiverSwapped Parms{};

	Parms.Character = Character;
	Parms.PreviousWeapon = PreviousWeapon;
	Parms.NewWeapon = NewWeapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnRiotModeEnded
// (Final, Native, Protected)
// Parameters:
// int32                                   NumberOfWavesSurvived                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TotalScore                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TotalKills                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TotalDismemberments                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeAlive                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnRiotModeEnded(int32 NumberOfWavesSurvived, int32 TotalScore, int32 TotalKills, int32 TotalDismemberments, float TimeAlive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnRiotModeEnded");

	Params::PhxTelemetryManager_OnRiotModeEnded Parms{};

	Parms.NumberOfWavesSurvived = NumberOfWavesSurvived;
	Parms.TotalScore = TotalScore;
	Parms.TotalKills = TotalKills;
	Parms.TotalDismemberments = TotalDismemberments;
	Parms.TimeAlive = TimeAlive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnRiotModeEndedTelemetry
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxTelemetryRiotMode_GeneralData&GeneralTelemetry                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnRiotModeEndedTelemetry(const struct FPhxTelemetryRiotMode_GeneralData& GeneralTelemetry)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnRiotModeEndedTelemetry");

	Params::PhxTelemetryManager_OnRiotModeEndedTelemetry Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnRiotModeItemPurchased
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxTelemetryRiotMode_ItemPurchaseData&ItemPurchasedTelemetry                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnRiotModeItemPurchased(const struct FPhxTelemetryRiotMode_ItemPurchaseData& ItemPurchasedTelemetry)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnRiotModeItemPurchased");

	Params::PhxTelemetryManager_OnRiotModeItemPurchased Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnRiotModePassivePerksSet
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxTelemetryRiotMode_PassivePerksData&PassivePerksTelemetry                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnRiotModePassivePerksSet(const struct FPhxTelemetryRiotMode_PassivePerksData& PassivePerksTelemetry)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnRiotModePassivePerksSet");

	Params::PhxTelemetryManager_OnRiotModePassivePerksSet Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTelemetryManager.OnRiotModeWaveCompleted
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FPhxTelemetryRiotMode_WaveCompletedData&WaveCompletedTelemetry                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTelemetryManager::OnRiotModeWaveCompleted(const struct FPhxTelemetryRiotMode_WaveCompletedData& WaveCompletedTelemetry)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTelemetryManager", "OnRiotModeWaveCompleted");

	Params::PhxTelemetryManager_OnRiotModeWaveCompleted Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTetherSplineComponent.AttachEndPointTo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTetherSplineComponent::AttachEndPointTo(class USceneComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTetherSplineComponent", "AttachEndPointTo");

	Params::PhxTetherSplineComponent_AttachEndPointTo Parms{};

	Parms.Component = Component;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTetherSplineComponent.GetEndPointTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UPhxTetherSplineComponent::GetEndPointTransform()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTetherSplineComponent", "GetEndPointTransform");

	Params::PhxTetherSplineComponent_GetEndPointTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTetherSplineComponent.ReleaseEndPoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bClearSplinePoints                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTetherSplineComponent::ReleaseEndPoint(bool bClearSplinePoints)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTetherSplineComponent", "ReleaseEndPoint");

	Params::PhxTetherSplineComponent_ReleaseEndPoint Parms{};

	Parms.bClearSplinePoints = bClearSplinePoints;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTetherSplineComponent.GetDesiredEndPointLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPhxTetherSplineComponent::GetDesiredEndPointLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTetherSplineComponent", "GetDesiredEndPointLocation");

	Params::PhxTetherSplineComponent_GetDesiredEndPointLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTetherSplineComponent.GetEndPointAttachComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* UPhxTetherSplineComponent::GetEndPointAttachComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTetherSplineComponent", "GetEndPointAttachComponent");

	Params::PhxTetherSplineComponent_GetEndPointAttachComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PigSpline.SetNextSpline
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class APigSpline>           Next                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APigSpline::SetNextSpline(TSubclassOf<class APigSpline> Next)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigSpline", "SetNextSpline");

	Params::PigSpline_SetNextSpline Parms{};

	Parms.Next = Next;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTraversalVolumeComponent.IsTraversalTypeAllowed
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EVolumeTraversalType                    TraversalType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxTraversalVolumeComponent::IsTraversalTypeAllowed(EVolumeTraversalType TraversalType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalVolumeComponent", "IsTraversalTypeAllowed");

	Params::PhxTraversalVolumeComponent_IsTraversalTypeAllowed Parms{};

	Parms.TraversalType = TraversalType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTraversalVolumeComponent.SetAllowedTraversalTypes
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// uint8                                   VolumeTraversalTypes                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxTraversalVolumeComponent::SetAllowedTraversalTypes(uint8 VolumeTraversalTypes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalVolumeComponent", "SetAllowedTraversalTypes");

	Params::PhxTraversalVolumeComponent_SetAllowedTraversalTypes Parms{};

	Parms.VolumeTraversalTypes = VolumeTraversalTypes;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxTraversalVolumeComponent.GetTraversalHeight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   PlayerZ                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPhxTraversalVolumeComponent::GetTraversalHeight(float PlayerZ) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTraversalVolumeComponent", "GetTraversalHeight");

	Params::PhxTraversalVolumeComponent_GetTraversalHeight Parms{};

	Parms.PlayerZ = PlayerZ;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxTutorialHintUI.AnimateIn
// (Event, Public, BlueprintEvent)

void UPhxTutorialHintUI::AnimateIn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTutorialHintUI", "AnimateIn");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxTutorialHintUI.AnimateOut
// (Event, Public, BlueprintEvent)

void UPhxTutorialHintUI::AnimateOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTutorialHintUI", "AnimateOut");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PhxTutorialHintUI.Setup
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FTutorialHintRequest&      InRequest                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhxTutorialHintUI::Setup(const struct FTutorialHintRequest& InRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxTutorialHintUI", "Setup");

	Params::PhxTutorialHintUI_Setup Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxUpgradeComponent.ApplyUpgrade
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UPhxWeaponModificationRecipe*UpgradeRecipe                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxUpgradeComponent::ApplyUpgrade(const class UPhxWeaponModificationRecipe* UpgradeRecipe)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxUpgradeComponent", "ApplyUpgrade");

	Params::PhxUpgradeComponent_ApplyUpgrade Parms{};

	Parms.UpgradeRecipe = UpgradeRecipe;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxUpgradeComponent.RemoveUpgrade
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UPhxWeaponModificationRecipe*UpgradeRecipe                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxUpgradeComponent::RemoveUpgrade(const class UPhxWeaponModificationRecipe* UpgradeRecipe)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxUpgradeComponent", "RemoveUpgrade");

	Params::PhxUpgradeComponent_RemoveUpgrade Parms{};

	Parms.UpgradeRecipe = UpgradeRecipe;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxUpgradeComponent.IsRecipeApplied
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UPhxWeaponModificationRecipe*UpgradeRecipe                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhxUpgradeComponent::IsRecipeApplied(const class UPhxWeaponModificationRecipe* UpgradeRecipe) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxUpgradeComponent", "IsRecipeApplied");

	Params::PhxUpgradeComponent_IsRecipeApplied Parms{};

	Parms.UpgradeRecipe = UpgradeRecipe;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxVehicle.ClearSplineFollowRequest
// (Final, Native, Public, BlueprintCallable)

void APhxVehicle::ClearSplineFollowRequest()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicle", "ClearSplineFollowRequest");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxVehicle.RequestSplineFollow
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FVehSplineFollowParams&    FollowParams                                           (Parm, NoDestructor, NativeAccessSpecifierPublic)

void APhxVehicle::RequestSplineFollow(const struct FVehSplineFollowParams& FollowParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxVehicle", "RequestSplineFollow");

	Params::PhxVehicle_RequestSplineFollow Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxViewTrigger.HandleComponentBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APhxViewTrigger::HandleComponentBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxViewTrigger", "HandleComponentBeginOverlap");

	Params::PhxViewTrigger_HandleComponentBeginOverlap Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxViewTrigger.HandleComponentEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxViewTrigger::HandleComponentEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxViewTrigger", "HandleComponentEndOverlap");

	Params::PhxViewTrigger_HandleComponentEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxViewTrigger.HandleFlashlightActivated
// (Final, Native, Protected)

void APhxViewTrigger::HandleFlashlightActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxViewTrigger", "HandleFlashlightActivated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxViewTrigger.HandleFlashlightDeactivated
// (Final, Native, Protected)

void APhxViewTrigger::HandleFlashlightDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxViewTrigger", "HandleFlashlightDeactivated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxViewTrigger.HandleOverlappingPlayerFocusTargetChanged
// (Final, Native, Protected)
// Parameters:
// class APhxPlayerCharacter*              Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           PreviousFocusTarget                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           NewFocusTarget                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxViewTrigger::HandleOverlappingPlayerFocusTargetChanged(class APhxPlayerCharacter* Player, class AActor* PreviousFocusTarget, class AActor* NewFocusTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxViewTrigger", "HandleOverlappingPlayerFocusTargetChanged");

	Params::PhxViewTrigger_HandleOverlappingPlayerFocusTargetChanged Parms{};

	Parms.Player = Player;
	Parms.PreviousFocusTarget = PreviousFocusTarget;
	Parms.NewFocusTarget = NewFocusTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxViewTrigger.SetTriggerEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnableTrigger                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxViewTrigger::SetTriggerEnabled(bool bEnableTrigger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxViewTrigger", "SetTriggerEnabled");

	Params::PhxViewTrigger_SetTriggerEnabled Parms{};

	Parms.bEnableTrigger = bEnableTrigger;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxViewTrigger.SetViewTargetActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     TargetActor                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APhxViewTrigger::SetViewTargetActor(const class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxViewTrigger", "SetViewTargetActor");

	Params::PhxViewTrigger_SetViewTargetActor Parms{};

	Parms.TargetActor = TargetActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWaitForAsyncLoadComplete.CreateTeleportCharacterAndWaitForStreaming
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxCharacter*                    Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   TimerInterval_0                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxWaitForAsyncLoadComplete*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxWaitForAsyncLoadComplete* UPhxWaitForAsyncLoadComplete::CreateTeleportCharacterAndWaitForStreaming(class UObject* WorldContextObject, class APhxCharacter* Character, const struct FTransform& Transform, float TimerInterval_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxWaitForAsyncLoadComplete", "CreateTeleportCharacterAndWaitForStreaming");

	Params::PhxWaitForAsyncLoadComplete_CreateTeleportCharacterAndWaitForStreaming Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Character = Character;
	Parms.Transform = std::move(Transform);
	Parms.TimerInterval_0 = TimerInterval_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWaitForAsyncLoadComplete.CreateWaitForAsyncLoadComplete
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimerInterval_0                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxWaitForAsyncLoadComplete*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxWaitForAsyncLoadComplete* UPhxWaitForAsyncLoadComplete::CreateWaitForAsyncLoadComplete(class UObject* WorldContextObject, float TimerInterval_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxWaitForAsyncLoadComplete", "CreateWaitForAsyncLoadComplete");

	Params::PhxWaitForAsyncLoadComplete_CreateWaitForAsyncLoadComplete Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TimerInterval_0 = TimerInterval_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWeakSpotComponent_Virus.OnOwnerTakeAnyDamage
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeakSpotComponent_Virus::OnOwnerTakeAnyDamage(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeakSpotComponent_Virus", "OnOwnerTakeAnyDamage");

	Params::PhxWeakSpotComponent_Virus_OnOwnerTakeAnyDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeakSpotComponent_Virus.OnOwnerTakeMeleeDamage
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPhxMeleeDamageEvent&      MeleeDamageEvent                                       (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeakSpotComponent_Virus::OnOwnerTakeMeleeDamage(class AActor* DamagedActor, float Damage, const struct FPhxMeleeDamageEvent& MeleeDamageEvent, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeakSpotComponent_Virus", "OnOwnerTakeMeleeDamage");

	Params::PhxWeakSpotComponent_Virus_OnOwnerTakeMeleeDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.MeleeDamageEvent = std::move(MeleeDamageEvent);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeakSpotComponent_Virus.OnVirusAimingChanged
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    AimingCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOn                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeakSpotComponent_Virus::OnVirusAimingChanged(class APhxCharacter* AimingCharacter, bool bOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeakSpotComponent_Virus", "OnVirusAimingChanged");

	Params::PhxWeakSpotComponent_Virus_OnVirusAimingChanged Parms{};

	Parms.AimingCharacter = AimingCharacter;
	Parms.bOn = bOn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeakSpotComponent_Virus.SpawnVirus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bQuickMutate                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhxWeakSpotComponent_Virus::SpawnVirus(bool bQuickMutate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeakSpotComponent_Virus", "SpawnVirus");

	Params::PhxWeakSpotComponent_Virus_SpawnVirus Parms{};

	Parms.bQuickMutate = bQuickMutate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWeaponSchematic.IsDataUploadedToPrinter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APhxWeaponSchematic::IsDataUploadedToPrinter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWeaponSchematic", "IsDataUploadedToPrinter");

	Params::PhxWeaponSchematic_IsDataUploadedToPrinter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldSettings.GetPhxWorldSettings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APhxWorldSettings*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APhxWorldSettings* APhxWorldSettings::GetPhxWorldSettings(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PhxWorldSettings", "GetPhxWorldSettings");

	Params::PhxWorldSettings_GetPhxWorldSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldSettings.GetLevelTags
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGameplayTagContainer            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayTagContainer APhxWorldSettings::GetLevelTags() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldSettings", "GetLevelTags");

	Params::PhxWorldSettings_GetLevelTags Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWorldSettings.GetTimeDilation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float APhxWorldSettings::GetTimeDilation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWorldSettings", "GetTimeDilation");

	Params::PhxWorldSettings_GetTimeDilation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PhxWoundManager.OnTexturesLoaded
// (Final, Native, Private)
// Parameters:
// bool                                    bLoadedSuccessfully                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UPhxWound*>&         LoadedWounds                                           (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UPhxWoundManager::OnTexturesLoaded(bool bLoadedSuccessfully, const TArray<class UPhxWound*>& LoadedWounds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWoundManager", "OnTexturesLoaded");

	Params::PhxWoundManager_OnTexturesLoaded Parms{};

	Parms.bLoadedSuccessfully = bLoadedSuccessfully;
	Parms.LoadedWounds = std::move(LoadedWounds);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PhxWoundManager.OnWoundTableChanged
// (Final, Native, Private)

void UPhxWoundManager::OnWoundTableChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhxWoundManager", "OnWoundTableChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PigPlatform.ActorHitByForce
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class AActor*                           ActorSelf                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Other                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   B                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APigPlatform::ActorHitByForce(class AActor* ActorSelf, class AActor* Other, const struct FVector& B, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigPlatform", "ActorHitByForce");

	Params::PigPlatform_ActorHitByForce Parms{};

	Parms.ActorSelf = ActorSelf;
	Parms.Other = Other;
	Parms.B = std::move(B);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PigPlatform.SetNextSpline
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class APigSpline>           Next                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APigPlatform::SetNextSpline(TSubclassOf<class APigSpline> Next)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigPlatform", "SetNextSpline");

	Params::PigPlatform_SetNextSpline Parms{};

	Parms.Next = Next;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PigPlatform.TriggerEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Other                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APigPlatform::TriggerEndOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigPlatform", "TriggerEndOverlap");

	Params::PigPlatform_TriggerEndOverlap Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.Other = Other;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PigPlatform.TriggerOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Other                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APigPlatform::TriggerOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigPlatform", "TriggerOverlap");

	Params::PigPlatform_TriggerOverlap Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.Other = Other;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PlaceholderVOWidget.SetLine
// (Event, Public, BlueprintEvent)
// Parameters:
// const class FString&                    Line                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlaceholderVOWidget::SetLine(const class FString& Line, float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlaceholderVOWidget", "SetLine");

	Params::PlaceholderVOWidget_SetLine Parms{};

	Parms.Line = std::move(Line);
	Parms.Duration = Duration;

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


// Function Phoenix.PPEChargeComponent.AddCharge
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPPEChargeComponent::AddCharge(float Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEChargeComponent", "AddCharge");

	Params::PPEChargeComponent_AddCharge Parms{};

	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PPEChargeComponent.GetCharge
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPPEChargeComponent::GetCharge() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEChargeComponent", "GetCharge");

	Params::PPEChargeComponent_GetCharge Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PPEChargeComponent.GetMaxCharge
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPPEChargeComponent::GetMaxCharge() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PPEChargeComponent", "GetMaxCharge");

	Params::PPEChargeComponent_GetMaxCharge Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PrintAnimActor.StartPrint
// (Event, Public, BlueprintEvent)

void APrintAnimActor::StartPrint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrintAnimActor", "StartPrint");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PrinterUploadElement.ApplyVID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class UVirtualItemData*           InVID                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterUploadElement::ApplyVID(const class UVirtualItemData* InVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterUploadElement", "ApplyVID");

	Params::PrinterUploadElement_ApplyVID Parms{};

	Parms.InVID = InVID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2UpgradeState.CharacterNotify
// (Final, Native, Protected)
// Parameters:
// const class UPhxAnimNotify*             Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterV2UpgradeState::CharacterNotify(const class UPhxAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2UpgradeState", "CharacterNotify");

	Params::PrinterV2UpgradeState_CharacterNotify Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterV2UpgradeState.PrinterNotify
// (Final, Native, Protected)
// Parameters:
// const class UPhxPrinterAnimNotify*      Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterV2UpgradeState::PrinterNotify(const class UPhxPrinterAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterV2UpgradeState", "PrinterNotify");

	Params::PrinterV2UpgradeState_PrinterNotify Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterWidget.GenerateMenu
// (Final, Native, Public, BlueprintCallable)

void UPrinterWidget::GenerateMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterWidget", "GenerateMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterWidget.ShowOutputMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ItemName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         OverlayPicture                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterWidget::ShowOutputMenu(class FName ItemName, class UTexture* OverlayPicture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterWidget", "ShowOutputMenu");

	Params::PrinterWidget_ShowOutputMenu Parms{};

	Parms.ItemName = ItemName;
	Parms.OverlayPicture = OverlayPicture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterWidget.ShowShopMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ItemName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   costTotal_0                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   costMetals_0                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   costBioplastics_0                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   costChemicals_0                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ownedMetals_0                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ownedBioplastics_0                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ownedChemicals_0                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         OverlayPicture                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPrinterWidget::ShowShopMenu(class FName ItemName, int32 costTotal_0, int32 costMetals_0, int32 costBioplastics_0, int32 costChemicals_0, int32 ownedMetals_0, int32 ownedBioplastics_0, int32 ownedChemicals_0, class UTexture* OverlayPicture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterWidget", "ShowShopMenu");

	Params::PrinterWidget_ShowShopMenu Parms{};

	Parms.ItemName = ItemName;
	Parms.costTotal_0 = costTotal_0;
	Parms.costMetals_0 = costMetals_0;
	Parms.costBioplastics_0 = costBioplastics_0;
	Parms.costChemicals_0 = costChemicals_0;
	Parms.ownedMetals_0 = ownedMetals_0;
	Parms.ownedBioplastics_0 = ownedBioplastics_0;
	Parms.ownedChemicals_0 = ownedChemicals_0;
	Parms.OverlayPicture = OverlayPicture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PrinterWidget.ShowUnusedMenu
// (Final, Native, Public, BlueprintCallable)

void UPrinterWidget::ShowUnusedMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PrinterWidget", "ShowUnusedMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PuzzlePad.GetCurrentWeightOnPad
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 APuzzlePad::GetCurrentWeightOnPad()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PuzzlePad", "GetCurrentWeightOnPad");

	Params::PuzzlePad_GetCurrentWeightOnPad Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PuzzlePad.IsTriggeredOn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APuzzlePad::IsTriggeredOn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PuzzlePad", "IsTriggeredOn");

	Params::PuzzlePad_IsTriggeredOn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.PuzzlePad.OnCurrentWeightOnPadChanged_BP
// (Event, Protected, BlueprintEvent)

void APuzzlePad::OnCurrentWeightOnPadChanged_BP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PuzzlePad", "OnCurrentWeightOnPadChanged_BP");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.PuzzlePad.OnPuzzlePadCapsuleOverlapBegin
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APuzzlePad::OnPuzzlePadCapsuleOverlapBegin(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PuzzlePad", "OnPuzzlePadCapsuleOverlapBegin");

	Params::PuzzlePad_OnPuzzlePadCapsuleOverlapBegin Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PuzzlePad.OnPuzzlePadCapsuleOverlapEnd
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APuzzlePad::OnPuzzlePadCapsuleOverlapEnd(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PuzzlePad", "OnPuzzlePadCapsuleOverlapEnd");

	Params::PuzzlePad_OnPuzzlePadCapsuleOverlapEnd Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.PuzzlePad.DoesRequirePower
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APuzzlePad::DoesRequirePower() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PuzzlePad", "DoesRequirePower");

	Params::PuzzlePad_DoesRequirePower Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.QteWidget.AnimateMultipleAction
// (Event, Public, BlueprintEvent)

void UQteWidget::AnimateMultipleAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "AnimateMultipleAction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.QteWidget.AnimateSingleAction
// (Event, Public, BlueprintEvent)

void UQteWidget::AnimateSingleAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "AnimateSingleAction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.QteWidget.FinishAction
// (Event, Public, BlueprintEvent)
// Parameters:
// EPhxQteDismissType                      DismissType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UQteWidget::FinishAction(EPhxQteDismissType DismissType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "FinishAction");

	Params::QteWidget_FinishAction Parms{};

	Parms.DismissType = DismissType;

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


// Function Phoenix.QteWidget.SetIcons
// (Event, Public, BlueprintEvent)
// Parameters:
// class UTexture*                         MainIcon                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         AltIcon                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShowLine                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UQteWidget::SetIcons(class UTexture* MainIcon, class UTexture* AltIcon, bool bShowLine)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "SetIcons");

	Params::QteWidget_SetIcons Parms{};

	Parms.MainIcon = MainIcon;
	Parms.AltIcon = AltIcon;
	Parms.bShowLine = bShowLine;

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


// Function Phoenix.QteWidget.Setup
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FQteRequest&               InQte                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UQteWidget::Setup(const struct FQteRequest& InQte)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "Setup");

	Params::QteWidget_Setup Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.QteWidget.UpdatePips
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector2D&                 LeftPip                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 RightPip                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UQteWidget::UpdatePips(const struct FVector2D& LeftPip, const struct FVector2D& RightPip)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "UpdatePips");

	Params::QteWidget_UpdatePips Parms{};

	Parms.LeftPip = std::move(LeftPip);
	Parms.RightPip = std::move(RightPip);

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


// Function Phoenix.QteWidget.UpdateProgress
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   Progress                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UQteWidget::UpdateProgress(float Progress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "UpdateProgress");

	Params::QteWidget_UpdateProgress Parms{};

	Parms.Progress = Progress;

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


// Function Phoenix.QteWidget.UpdateWiggle
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector2D&                 LeftPip                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 RightPip                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UQteWidget::UpdateWiggle(const struct FVector2D& LeftPip, const struct FVector2D& RightPip)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("QteWidget", "UpdateWiggle");

	Params::QteWidget_UpdateWiggle Parms{};

	Parms.LeftPip = std::move(LeftPip);
	Parms.RightPip = std::move(RightPip);

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


// Function Phoenix.Recycler.GetInteractableComp
// (Final, Native, Public)
// Parameters:
// class UInteractableComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInteractableComponent* ARecycler::GetInteractableComp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Recycler", "GetInteractableComp");

	Params::Recycler_GetInteractableComp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.RecyclerMainState.BeginInteract
// (Final, Native, Public)
// Parameters:
// class APhxCharacter*                    RecyclerUser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URecyclerMainState::BeginInteract(class APhxCharacter* RecyclerUser)
{
	static class UFunction* Func = nullptr;

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

	Params::RecyclerMainState_BeginInteract Parms{};

	Parms.RecyclerUser = RecyclerUser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.RecyclerMainState.ShutdownRecycler
// (Final, Native, Public)

void URecyclerMainState::ShutdownRecycler()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecyclerMainState", "ShutdownRecycler");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.RecyclerMainState.StartRecycler
// (Final, Native, Public)
// Parameters:
// class APhxPlayerCharacter*              RecyclerUser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URecyclerMainState::StartRecycler(class APhxPlayerCharacter* RecyclerUser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecyclerMainState", "StartRecycler");

	Params::RecyclerMainState_StartRecycler Parms{};

	Parms.RecyclerUser = RecyclerUser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.ReticleWidget.OnWeaponTargetChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// EWeaponTarget                           NewWeaponTarget                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UReticleWidget::OnWeaponTargetChanged(EWeaponTarget NewWeaponTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ReticleWidget", "OnWeaponTargetChanged");

	Params::ReticleWidget_OnWeaponTargetChanged Parms{};

	Parms.NewWeaponTarget = NewWeaponTarget;

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


// Function Phoenix.ReticleWidget.IsSecondaryUnlocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UReticleWidget::IsSecondaryUnlocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ReticleWidget", "IsSecondaryUnlocked");

	Params::ReticleWidget_IsSecondaryUnlocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.RiotLeaderboardScoreBlueprintLibrary.MakeRiotLeaderboardScoreFromLeaderboardRow
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FSDSLeaderboardRow&        LeaderboardRow                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FRiotLeaderboardScore            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FRiotLeaderboardScore URiotLeaderboardScoreBlueprintLibrary::MakeRiotLeaderboardScoreFromLeaderboardRow(const struct FSDSLeaderboardRow& LeaderboardRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RiotLeaderboardScoreBlueprintLibrary", "MakeRiotLeaderboardScoreFromLeaderboardRow");

	Params::RiotLeaderboardScoreBlueprintLibrary_MakeRiotLeaderboardScoreFromLeaderboardRow Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.ScrollingButton.OnRotateTitle
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bRotateRight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UScrollingButton::OnRotateTitle(bool bRotateRight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScrollingButton", "OnRotateTitle");

	Params::ScrollingButton_OnRotateTitle Parms{};

	Parms.bRotateRight = bRotateRight;

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


// Function Phoenix.ScrollingButton.SetLabelText
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      NewLabelText                                           (Parm, NativeAccessSpecifierPublic)

void UScrollingButton::SetLabelText(const class FText& NewLabelText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScrollingButton", "SetLabelText");

	Params::ScrollingButton_SetLabelText Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSApplyHandler.ApplyPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSApplyHandler::ApplyPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSApplyHandler", "ApplyPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.AsyncLoadAndPlay
// (Final, Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class UBinkMediaTexture> InMediaTexture                                         (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             InMeshComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInterface*               InSourceMaterial                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(class UMaterialInstanceDynamic* DynamicMaterialInstance)>&Callback                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void ASDSBinkMediaActor::AsyncLoadAndPlay(TSoftObjectPtr<class UBinkMediaTexture> InMediaTexture, class UStaticMeshComponent* InMeshComp, class UMaterialInterface* InSourceMaterial, const TDelegate<void(class UMaterialInstanceDynamic* DynamicMaterialInstance)>& Callback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "AsyncLoadAndPlay");

	Params::SDSBinkMediaActor_AsyncLoadAndPlay Parms{};

	Parms.InMediaTexture = InMediaTexture;
	Parms.InMeshComp = InMeshComp;
	Parms.InSourceMaterial = InSourceMaterial;
	Parms.Callback = Callback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.CreateDynamicMaterial
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class UBinkMediaTexture> InMediaTexture                                         (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             InMeshComp                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInterface*               InSourceMaterial                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASDSBinkMediaActor::CreateDynamicMaterial(TSoftObjectPtr<class UBinkMediaTexture> InMediaTexture, class UStaticMeshComponent* InMeshComp, class UMaterialInterface* InSourceMaterial)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "CreateDynamicMaterial");

	Params::SDSBinkMediaActor_CreateDynamicMaterial Parms{};

	Parms.InMediaTexture = InMediaTexture;
	Parms.InMeshComp = InMeshComp;
	Parms.InSourceMaterial = InSourceMaterial;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.Pause
// (Final, Native, Public, BlueprintCallable)

void ASDSBinkMediaActor::Pause()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "Pause");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.Play
// (Final, Native, Public, BlueprintCallable)

void ASDSBinkMediaActor::Play()
{
	static class UFunction* Func = nullptr;

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.PlaySound
// (Final, Native, Public, BlueprintCallable)

void ASDSBinkMediaActor::PlaySound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "PlaySound");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.Resume
// (Final, Native, Public, BlueprintCallable)

void ASDSBinkMediaActor::Resume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "Resume");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.Rewind
// (Final, Native, Public, BlueprintCallable)

void ASDSBinkMediaActor::Rewind()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "Rewind");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.SetMediaTexture
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class UBinkMediaTexture> InMediaTexture                                         (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASDSBinkMediaActor::SetMediaTexture(TSoftObjectPtr<class UBinkMediaTexture> InMediaTexture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "SetMediaTexture");

	Params::SDSBinkMediaActor_SetMediaTexture Parms{};

	Parms.InMediaTexture = InMediaTexture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.SetSoundEvent
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class UAkAudioEvent>     InSoundEvent                                           (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASDSBinkMediaActor::SetSoundEvent(TSoftObjectPtr<class UAkAudioEvent> InSoundEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "SetSoundEvent");

	Params::SDSBinkMediaActor_SetSoundEvent Parms{};

	Parms.InSoundEvent = InSoundEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSBinkMediaActor.GetDynamicMaterialInstance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMaterialInstanceDynamic*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* ASDSBinkMediaActor::GetDynamicMaterialInstance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSBinkMediaActor", "GetDynamicMaterialInstance");

	Params::SDSBinkMediaActor_GetDynamicMaterialInstance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSDirectionInputHandler.DirectionInput
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromPlayerMoveBinding                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ISDSDirectionInputHandler::DirectionInput(EInputDirection Direction, bool bFromPlayerMoveBinding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSDirectionInputHandler", "DirectionInput");

	Params::SDSDirectionInputHandler_DirectionInput Parms{};

	Parms.Direction = Direction;
	Parms.bFromPlayerMoveBinding = bFromPlayerMoveBinding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSExtendedUIInputHandler.ShoulderLeftPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSExtendedUIInputHandler::ShoulderLeftPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSExtendedUIInputHandler", "ShoulderLeftPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSExtendedUIInputHandler.ShoulderRightPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSExtendedUIInputHandler::ShoulderRightPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSExtendedUIInputHandler", "ShoulderRightPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSExtendedUIInputHandler.TriggerLeftPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSExtendedUIInputHandler::TriggerLeftPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSExtendedUIInputHandler", "TriggerLeftPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSExtendedUIInputHandler.TriggerRightPressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSExtendedUIInputHandler::TriggerRightPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSExtendedUIInputHandler", "TriggerRightPressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSGridWidget.CloseWindow
// (Final, Native, Public, BlueprintCallable)

void USDSGridWidget::CloseWindow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "CloseWindow");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSGridWidget.GetAdjacent
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UPhxSelectable*             Target                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInputDirection                   Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPhxSelectable*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSelectable* USDSGridWidget::GetAdjacent(const class UPhxSelectable* Target, const EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "GetAdjacent");

	Params::SDSGridWidget_GetAdjacent Parms{};

	Parms.Target = Target;
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSGridWidget.HandleBackgroundVisibility
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)

void USDSGridWidget::HandleBackgroundVisibility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "HandleBackgroundVisibility");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSGridWidget.IsSelectable
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UPhxSelectable*             Target                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USDSGridWidget::IsSelectable(const class UPhxSelectable* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "IsSelectable");

	Params::SDSGridWidget_IsSelectable Parms{};

	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSGridWidget.PlayGlobalSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UAkAudioEvent*              Sound                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSGridWidget::PlayGlobalSound(const class UAkAudioEvent* Sound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "PlayGlobalSound");

	Params::SDSGridWidget_PlayGlobalSound Parms{};

	Parms.Sound = Sound;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSGridWidget.SelectFirstAvailable
// (Final, Native, Public, BlueprintCallable)

void USDSGridWidget::SelectFirstAvailable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "SelectFirstAvailable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSGridWidget.SetActiveContainer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UGridPanel*                       ActiveGridPanel                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSGridWidget::SetActiveContainer(class UGridPanel* ActiveGridPanel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "SetActiveContainer");

	Params::SDSGridWidget_SetActiveContainer Parms{};

	Parms.ActiveGridPanel = ActiveGridPanel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSGridWidget.GetSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxSelectable*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxSelectable* USDSGridWidget::GetSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSGridWidget", "GetSelected");

	Params::SDSGridWidget_GetSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSKeycodeHintButton.SetLore
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSKeycodeHintButton::SetLore(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSKeycodeHintButton", "SetLore");

	Params::SDSKeycodeHintButton_SetLore Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSKeycodeHintButton.SetThumbnail
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TSoftObjectPtr<class UTexture2D>& InSoftTexture                                          (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSKeycodeHintButton::SetThumbnail(const TSoftObjectPtr<class UTexture2D>& InSoftTexture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSKeycodeHintButton", "SetThumbnail");

	Params::SDSKeycodeHintButton_SetThumbnail Parms{};

	Parms.InSoftTexture = InSoftTexture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSLeftStickInputHandler.LeftStickInput
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EInputDirection                         Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ISDSLeftStickInputHandler::LeftStickInput(EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSLeftStickInputHandler", "LeftStickInput");

	Params::SDSLeftStickInputHandler_LeftStickInput Parms{};

	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSRestoreHandler.RestorePressed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void ISDSRestoreHandler::RestorePressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SDSRestoreHandler", "RestorePressed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USDSUISystem*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSUISystem* USDSUISystem::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SDSUISystem", "Get");

	Params::SDSUISystem_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.Apply
// (Final, Native, Private)

void USDSUISystem::Apply()
{
	static class UFunction* Func = nullptr;

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.Cancel
// (Final, Native, Private)

void USDSUISystem::Cancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "Cancel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.CloseWarningNotification
// (Final, Native, Public, BlueprintCallable)

void USDSUISystem::CloseWarningNotification()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "CloseWarningNotification");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.Confirm
// (Final, Native, Private)

void USDSUISystem::Confirm()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "Confirm");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.DirectionInput
// (Final, Native, Private)
// Parameters:
// const EInputDirection                   Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromPlayerMoveBinding                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::DirectionInput(const EInputDirection Direction, bool bFromPlayerMoveBinding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "DirectionInput");

	Params::SDSUISystem_DirectionInput Parms{};

	Parms.Direction = Direction;
	Parms.bFromPlayerMoveBinding = bFromPlayerMoveBinding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.DisableBootNotifications
// (Final, Native, Public, BlueprintCallable)

void USDSUISystem::DisableBootNotifications()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "DisableBootNotifications");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.DisplayWarningNotification
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSUISystem::DisplayWarningNotification(const class FText& InMessage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "DisplayWarningNotification");

	Params::SDSUISystem_DisplayWarningNotification Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.ForceUICompositeModeKeepEnable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::ForceUICompositeModeKeepEnable(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "ForceUICompositeModeKeepEnable");

	Params::SDSUISystem_ForceUICompositeModeKeepEnable Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.GetSDSToolTipWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UUserWidget*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUserWidget* USDSUISystem::GetSDSToolTipWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "GetSDSToolTipWidget");

	Params::SDSUISystem_GetSDSToolTipWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.LeftStickInput
// (Final, Native, Private)
// Parameters:
// const EInputDirection                   Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::LeftStickInput(const EInputDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "LeftStickInput");

	Params::SDSUISystem_LeftStickInput Parms{};

	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.MoveForward
// (Final, Native, Private)
// Parameters:
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::MoveForward(float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "MoveForward");

	Params::SDSUISystem_MoveForward Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.MoveRight
// (Final, Native, Private)
// Parameters:
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::MoveRight(float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "MoveRight");

	Params::SDSUISystem_MoveRight Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.NotifyMenuClosing
// (Final, Native, Public, BlueprintCallable)

void USDSUISystem::NotifyMenuClosing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "NotifyMenuClosing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.OnSimpleNotificationRemoved
// (Final, Native, Private)

void USDSUISystem::OnSimpleNotificationRemoved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "OnSimpleNotificationRemoved");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.OnSubtitlesUpdated
// (Final, Native, Private, HasOutParams)
// Parameters:
// const class FText&                      PrimaryText                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FText&                      SecondaryText                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void USDSUISystem::OnSubtitlesUpdated(const class FText& PrimaryText, const class FText& SecondaryText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "OnSubtitlesUpdated");

	Params::SDSUISystem_OnSubtitlesUpdated Parms{};

	Parms.PrimaryText = std::move(PrimaryText);
	Parms.SecondaryText = std::move(SecondaryText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.PopSaveNotification
// (Final, Native, Public, BlueprintCallable)

void USDSUISystem::PopSaveNotification()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "PopSaveNotification");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.PopWidget
// (Final, Native, Private)

void USDSUISystem::PopWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "PopWidget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.PushSaveNotification
// (Final, Native, Public, BlueprintCallable)

void USDSUISystem::PushSaveNotification()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "PushSaveNotification");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.PushWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUserWidget*                      InWidget                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAddToViewport                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::PushWidget(class UUserWidget* InWidget, bool bAddToViewport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "PushWidget");

	Params::SDSUISystem_PushWidget Parms{};

	Parms.InWidget = InWidget;
	Parms.bAddToViewport = bAddToViewport;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.QuickSwapCancel
// (Final, Native, Private)

void USDSUISystem::QuickSwapCancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "QuickSwapCancel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.QuickSwapDirectionInput
// (Final, Native, Private)
// Parameters:
// const EInputDirection                   Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromPlayerMoveBinding                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::QuickSwapDirectionInput(const EInputDirection Direction, bool bFromPlayerMoveBinding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "QuickSwapDirectionInput");

	Params::SDSUISystem_QuickSwapDirectionInput Parms{};

	Parms.Direction = Direction;
	Parms.bFromPlayerMoveBinding = bFromPlayerMoveBinding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.QuickSwapEquip
// (Final, Native, Private)

void USDSUISystem::QuickSwapEquip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "QuickSwapEquip");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.RemoveAllWidgets
// (Final, Native, Public, BlueprintCallable)

void USDSUISystem::RemoveAllWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RemoveAllWidgets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.RemoveTopWidget
// (Final, Native, Public, BlueprintCallable)

void USDSUISystem::RemoveTopWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RemoveTopWidget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.RemoveWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUserWidget*                      Widget                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::RemoveWidget(class UUserWidget* Widget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RemoveWidget");

	Params::SDSUISystem_RemoveWidget Parms{};

	Parms.Widget = Widget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.RequestBackgroundScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class USDSScreenWidget>     BackgroundScreen                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USDSScreenWidget*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSScreenWidget* USDSUISystem::RequestBackgroundScreen(TSubclassOf<class USDSScreenWidget> BackgroundScreen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RequestBackgroundScreen");

	Params::SDSUISystem_RequestBackgroundScreen Parms{};

	Parms.BackgroundScreen = BackgroundScreen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.RequestOneButtonPrompt
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnConfirm                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class USDSPromptWidget>     PromptClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::RequestOneButtonPrompt(const class FText& InMessage, const TDelegate<void()>& OnConfirm, TSubclassOf<class USDSPromptWidget> PromptClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RequestOneButtonPrompt");

	Params::SDSUISystem_RequestOneButtonPrompt Parms{};

	Parms.InMessage = std::move(InMessage);
	Parms.OnConfirm = OnConfirm;
	Parms.PromptClass = PromptClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.RequestProgressPrompt
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   StartValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnCancel                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class USDSPromptWidget>     PromptClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USDSPromptWidgetProgress*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSPromptWidgetProgress* USDSUISystem::RequestProgressPrompt(const class FText& InMessage, float StartValue, const TDelegate<void()>& OnCancel, TSubclassOf<class USDSPromptWidget> PromptClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RequestProgressPrompt");

	Params::SDSUISystem_RequestProgressPrompt Parms{};

	Parms.InMessage = std::move(InMessage);
	Parms.StartValue = StartValue;
	Parms.OnCancel = OnCancel;
	Parms.PromptClass = PromptClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.RequestScreen
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSoftClassPtr<class UClass>             ScreenClass                                            (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(class USDSScreenWidget* NewScreen)>&Callback                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class APlayerController*                InController                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bHideCurrent                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      BreadcrumbOverride                                     (ConstParm, Parm, NativeAccessSpecifierPublic)

void USDSUISystem::RequestScreen(TSoftClassPtr<class UClass> ScreenClass, const TDelegate<void(class USDSScreenWidget* NewScreen)>& Callback, class APlayerController* InController, bool bHideCurrent, const class FText& BreadcrumbOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RequestScreen");

	Params::SDSUISystem_RequestScreen Parms{};

	Parms.ScreenClass = ScreenClass;
	Parms.Callback = Callback;
	Parms.InController = InController;
	Parms.bHideCurrent = bHideCurrent;
	Parms.BreadcrumbOverride = std::move(BreadcrumbOverride);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.RequestSimpleNotification
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TSubclassOf<class USDSSimpleNotification>NotificationClass                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USDSSimpleNotification*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSSimpleNotification* USDSUISystem::RequestSimpleNotification(const class FText& InMessage, TSubclassOf<class USDSSimpleNotification> NotificationClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RequestSimpleNotification");

	Params::SDSUISystem_RequestSimpleNotification Parms{};

	Parms.InMessage = std::move(InMessage);
	Parms.NotificationClass = NotificationClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.RequestTwoButtonPrompt
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnConfirm                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnCancel                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class USDSPromptWidget>     PromptClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::RequestTwoButtonPrompt(const class FText& InMessage, const TDelegate<void()>& OnConfirm, const TDelegate<void()>& OnCancel, TSubclassOf<class USDSPromptWidget> PromptClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RequestTwoButtonPrompt");

	Params::SDSUISystem_RequestTwoButtonPrompt Parms{};

	Parms.InMessage = std::move(InMessage);
	Parms.OnConfirm = OnConfirm;
	Parms.OnCancel = OnCancel;
	Parms.PromptClass = PromptClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.RequestTwoButtonPromptExtended
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InMessage                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnConfirm                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                OnCancel                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class USDSPromptWidget>     PromptClass                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::RequestTwoButtonPromptExtended(const class FText& InMessage, const TDelegate<void()>& OnConfirm, const TDelegate<void()>& OnCancel, TSubclassOf<class USDSPromptWidget> PromptClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "RequestTwoButtonPromptExtended");

	Params::SDSUISystem_RequestTwoButtonPromptExtended Parms{};

	Parms.InMessage = std::move(InMessage);
	Parms.OnConfirm = OnConfirm;
	Parms.OnCancel = OnCancel;
	Parms.PromptClass = PromptClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.Restore
// (Final, Native, Private)

void USDSUISystem::Restore()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "Restore");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.SetModalDialogOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsOpen                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USDSUISystem::SetModalDialogOpen(bool bIsOpen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "SetModalDialogOpen");

	Params::SDSUISystem_SetModalDialogOpen Parms{};

	Parms.bIsOpen = bIsOpen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.ShoulderLeft
// (Final, Native, Private)

void USDSUISystem::ShoulderLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "ShoulderLeft");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.ShoulderRight
// (Final, Native, Private)

void USDSUISystem::ShoulderRight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "ShoulderRight");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.TriggerLeft
// (Final, Native, Private)

void USDSUISystem::TriggerLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "TriggerLeft");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.TriggerRight
// (Final, Native, Private)

void USDSUISystem::TriggerRight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "TriggerRight");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SDSUISystem.GetBackgroundScreen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USDSScreenWidget*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USDSScreenWidget* USDSUISystem::GetBackgroundScreen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "GetBackgroundScreen");

	Params::SDSUISystem_GetBackgroundScreen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.GetTopWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UUserWidget*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUserWidget* USDSUISystem::GetTopWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "GetTopWidget");

	Params::SDSUISystem_GetTopWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.IsActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USDSUISystem::IsActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "IsActive");

	Params::SDSUISystem_IsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.IsBootNotificationsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USDSUISystem::IsBootNotificationsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "IsBootNotificationsEnabled");

	Params::SDSUISystem_IsBootNotificationsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.IsInEndingCredits
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USDSUISystem::IsInEndingCredits() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "IsInEndingCredits");

	Params::SDSUISystem_IsInEndingCredits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SDSUISystem.IsModalDialogOpen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USDSUISystem::IsModalDialogOpen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SDSUISystem", "IsModalDialogOpen");

	Params::SDSUISystem_IsModalDialogOpen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.SessionLobbyWidget.LeaveSession
// (Final, Native, Public, BlueprintCallable)

void USessionLobbyWidget::LeaveSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SessionLobbyWidget", "LeaveSession");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SessionLobbyWidget.StartSession
// (Final, Native, Public, BlueprintCallable)

void USessionLobbyWidget::StartSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SessionLobbyWidget", "StartSession");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SessionLobbyWidget.UpdateClientList
// (Final, Native, Public, BlueprintCallable)

void USessionLobbyWidget::UpdateClientList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SessionLobbyWidget", "UpdateClientList");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SoundControllerComponent.Kick
// (Final, Native, Protected, BlueprintCallable)

void USoundControllerComponent::Kick()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundControllerComponent", "Kick");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SoundControllerComponent.NextSound
// (Final, Native, Protected, BlueprintCallable)

void USoundControllerComponent::NextSound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundControllerComponent", "NextSound");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SoundControllerComponent.PlaySound
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USoundControllerComponent::PlaySound(bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundControllerComponent", "PlaySound");

	Params::SoundControllerComponent_PlaySound Parms{};

	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SoundControllerComponent.SelectSound
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    SoundId                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRepeatSound                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Interval                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USoundControllerComponent::SelectSound(class UAkAudioEvent* SoundId, bool bRepeatSound, float Interval)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundControllerComponent", "SelectSound");

	Params::SoundControllerComponent_SelectSound Parms{};

	Parms.SoundId = SoundId;
	Parms.bRepeatSound = bRepeatSound;
	Parms.Interval = Interval;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SoundControllerComponent.StopSound
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USoundControllerComponent::StopSound(bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundControllerComponent", "StopSound");

	Params::SoundControllerComponent_StopSound Parms{};

	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.SoundControllerComponent.ToggleSound
// (Final, Native, Protected, BlueprintCallable)

void USoundControllerComponent::ToggleSound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundControllerComponent", "ToggleSound");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TitleScreenWidget.ChangeButtonText
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   ButtonIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTitleScreenWidget::ChangeButtonText(int32 ButtonIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TitleScreenWidget", "ChangeButtonText");

	Params::TitleScreenWidget_ChangeButtonText Parms{};

	Parms.ButtonIndex = ButtonIndex;

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


// Function Phoenix.TitleScreenWidget.OnRotateTitle
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bRotateRight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTitleScreenWidget::OnRotateTitle(bool bRotateRight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TitleScreenWidget", "OnRotateTitle");

	Params::TitleScreenWidget_OnRotateTitle Parms{};

	Parms.bRotateRight = bRotateRight;

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


// Function Phoenix.TitleScreenWidget.GetLevelSelectWidget
// (Final, Native, Public, Const)
// Parameters:
// class ULevelSelectWidget*               ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULevelSelectWidget* UTitleScreenWidget::GetLevelSelectWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TitleScreenWidget", "GetLevelSelectWidget");

	Params::TitleScreenWidget_GetLevelSelectWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.TitleScreenWidget.GetOptionsWidget
// (Final, Native, Public, Const)
// Parameters:
// class UOptionsWidget*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UOptionsWidget* UTitleScreenWidget::GetOptionsWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TitleScreenWidget", "GetOptionsWidget");

	Params::TitleScreenWidget_GetOptionsWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.TraversalState.OnNodeAbilityUpdateRequested
// (Final, Native, Protected)
// Parameters:
// const class UPhxGameplayAbilityDefinition_Traverse_Fixed*AbilityDefinition                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     NextNode                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTraversalState::OnNodeAbilityUpdateRequested(const class UPhxGameplayAbilityDefinition_Traverse_Fixed* AbilityDefinition, const class AActor* NextNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TraversalState", "OnNodeAbilityUpdateRequested");

	Params::TraversalState_OnNodeAbilityUpdateRequested Parms{};

	Parms.AbilityDefinition = AbilityDefinition;
	Parms.NextNode = NextNode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TraversalState.OnSplineAbilitySetUpdateRequested
// (Final, Native, Protected)

void UTraversalState::OnSplineAbilitySetUpdateRequested()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TraversalState", "OnSplineAbilitySetUpdateRequested");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.TraversalState.OnSplineActionChangeRequested
// (Final, Native, Protected)
// Parameters:
// ESplineTraversalAction                  NewAction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTraversalState::OnSplineActionChangeRequested(ESplineTraversalAction NewAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TraversalState", "OnSplineActionChangeRequested");

	Params::TraversalState_OnSplineActionChangeRequested Parms{};

	Parms.NewAction = NewAction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.VehicleSeatComponent.GetIsOccupied
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UVehicleSeatComponent::GetIsOccupied()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleSeatComponent", "GetIsOccupied");

	Params::VehicleSeatComponent_GetIsOccupied Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.VehicleSeatComponent.GetCurrentViewpoint
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPassengerViewpointComponent*     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPassengerViewpointComponent* UVehicleSeatComponent::GetCurrentViewpoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleSeatComponent", "GetCurrentViewpoint");

	Params::VehicleSeatComponent_GetCurrentViewpoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSMediaPanel.GetMediaPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMediaPlayer*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMediaPlayer* AWSMediaPanel::GetMediaPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSMediaPanel", "GetMediaPlayer");

	Params::WSMediaPanel_GetMediaPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSEndScreen.OnEndScreenFinished
// (Event, Public, BlueprintEvent)

void AWSEndScreen::OnEndScreenFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSEndScreen", "OnEndScreenFinished");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSEndScreen.GetScreenTimeElapsed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AWSEndScreen::GetScreenTimeElapsed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSEndScreen", "GetScreenTimeElapsed");

	Params::WSEndScreen_GetScreenTimeElapsed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSEndScreen.GetScreenTimeRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AWSEndScreen::GetScreenTimeRemaining() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSEndScreen", "GetScreenTimeRemaining");

	Params::WSEndScreen_GetScreenTimeRemaining Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSInventoryItemUI.ClearItemData
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AWSInventoryItemUI::ClearItemData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInventoryItemUI", "ClearItemData");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSInventoryItemUI.SetItemData
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FItemData&                 InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AWSInventoryItemUI::SetItemData(const struct FItemData& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSInventoryItemUI", "SetItemData");

	Params::WSInventoryItemUI_SetItemData Parms{};

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

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


// Function Phoenix.WSMenu.SetChildPanel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class AWSPanel>             InClass                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSMenu::SetChildPanel(TSubclassOf<class AWSPanel> InClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSMenu", "SetChildPanel");

	Params::WSMenu_SetChildPanel Parms{};

	Parms.InClass = InClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSMenu.SetNavigationVisibility
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSMenu::SetNavigationVisibility(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSMenu", "SetNavigationVisibility");

	Params::WSMenu_SetNavigationVisibility Parms{};

	Parms.bVisible = bVisible;

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


// Function Phoenix.WSMenu.SetSelection
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   SelectionIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAnimate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRightHand                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSMenu::SetSelection(int32 SelectionIndex, bool bAnimate, bool bRightHand)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSMenu", "SetSelection");

	Params::WSMenu_SetSelection Parms{};

	Parms.SelectionIndex = SelectionIndex;
	Parms.bAnimate = bAnimate;
	Parms.bRightHand = bRightHand;

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


// Function Phoenix.WSMenu.GetActiveSelectable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWSSelectable*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSSelectable* AWSMenu::GetActiveSelectable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSMenu", "GetActiveSelectable");

	Params::WSMenu_GetActiveSelectable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSMenu.GetChildPanel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWSPanel*                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSPanel* AWSMenu::GetChildPanel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSMenu", "GetChildPanel");

	Params::WSMenu_GetChildPanel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSMenu.GetSelectables
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AWSSelectable*>            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AWSSelectable*> AWSMenu::GetSelectables() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSMenu", "GetSelectables");

	Params::WSMenu_GetSelectables Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSLevelMenu.GetDemoLevelAssets
// (Final, Native, Public, Const)
// Parameters:
// const TArray<class FName>               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class FName> AWSLevelMenu::GetDemoLevelAssets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLevelMenu", "GetDemoLevelAssets");

	Params::WSLevelMenu_GetDemoLevelAssets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSLevelMenu.GetLevelAssets
// (Final, Native, Public, Const)
// Parameters:
// const TArray<class FName>               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class FName> AWSLevelMenu::GetLevelAssets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLevelMenu", "GetLevelAssets");

	Params::WSLevelMenu_GetLevelAssets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSLevelMenu.GetLevelTransitionAssets
// (Final, Native, Public, Const)
// Parameters:
// const TArray<class ULevelTransitionDataAsset*>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class ULevelTransitionDataAsset*> AWSLevelMenu::GetLevelTransitionAssets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLevelMenu", "GetLevelTransitionAssets");

	Params::WSLevelMenu_GetLevelTransitionAssets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSLockPickUI.HideUI
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSLockPickUI::HideUI(bool bSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLockPickUI", "HideUI");

	Params::WSLockPickUI_HideUI Parms{};

	Parms.bSuccess = bSuccess;

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


// Function Phoenix.WSLockPickUI.ShowUI
// (Event, Public, BlueprintEvent)

void AWSLockPickUI::ShowUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLockPickUI", "ShowUI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSLockPickUI.UpdateKnobSlider
// (Event, Public, BlueprintEvent)
// Parameters:
// uint8                                   SliderIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsSliding                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSLockPickUI::UpdateKnobSlider(uint8 SliderIndex, float Value, bool bIsSliding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLockPickUI", "UpdateKnobSlider");

	Params::WSLockPickUI_UpdateKnobSlider Parms{};

	Parms.SliderIndex = SliderIndex;
	Parms.Value = Value;
	Parms.bIsSliding = bIsSliding;

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


// Function Phoenix.WSLockPickUI.UpdateKnobSolved
// (Event, Public, BlueprintEvent)
// Parameters:
// uint8                                   SliderIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsSolved                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSLockPickUI::UpdateKnobSolved(uint8 SliderIndex, bool bIsSolved)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLockPickUI", "UpdateKnobSolved");

	Params::WSLockPickUI_UpdateKnobSolved Parms{};

	Parms.SliderIndex = SliderIndex;
	Parms.bIsSolved = bIsSolved;

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


// Function Phoenix.WSLockPickUI.UpdateSelectedKnob
// (Event, Public, BlueprintEvent)
// Parameters:
// uint8                                   SliderIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSLockPickUI::UpdateSelectedKnob(uint8 SliderIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLockPickUI", "UpdateSelectedKnob");

	Params::WSLockPickUI_UpdateSelectedKnob Parms{};

	Parms.SliderIndex = SliderIndex;

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


// Function Phoenix.WSLockPickUI.UpdateTimer
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSLockPickUI::UpdateTimer(float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSLockPickUI", "UpdateTimer");

	Params::WSLockPickUI_UpdateTimer Parms{};

	Parms.Value = Value;

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


// Function Phoenix.WSPrinterButton.NotifyInitialized
// (Event, Public, BlueprintEvent)

void AWSPrinterButton::NotifyInitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPrinterButton", "NotifyInitialized");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPrinterButton.SetAffordableVisuals
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bAffordable                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPrinterButton::SetAffordableVisuals(bool bAffordable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPrinterButton", "SetAffordableVisuals");

	Params::WSPrinterButton_SetAffordableVisuals Parms{};

	Parms.bAffordable = bAffordable;

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


// Function Phoenix.WSPrinterButton.SetItemData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FItemData&                 InItemData                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AWSPrinterButton::SetItemData(const struct FItemData& InItemData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPrinterButton", "SetItemData");

	Params::WSPrinterButton_SetItemData Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSPrinterButton.SetVirtualItemData
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UVirtualItemData*                 InVID                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPrinterButton::SetVirtualItemData(class UVirtualItemData* InVID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPrinterButton", "SetVirtualItemData");

	Params::WSPrinterButton_SetVirtualItemData Parms{};

	Parms.InVID = InVID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSPrinterUI.NotifyResizeHologram
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bBig                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSPrinterUI::NotifyResizeHologram(bool bBig)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPrinterUI", "NotifyResizeHologram");

	Params::WSPrinterUI_NotifyResizeHologram Parms{};

	Parms.bBig = bBig;

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


// Function Phoenix.WSPrinterUI.RefreshPanels
// (Event, Public, BlueprintEvent)

void AWSPrinterUI::RefreshPanels()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPrinterUI", "RefreshPanels");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSPrinterUI.GetSelected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWSPrinterButton*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWSPrinterButton* AWSPrinterUI::GetSelected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSPrinterUI", "GetSelected");

	Params::WSPrinterUI_GetSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSRecipeButton.GetRecipe
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPhxCraftingRecipe*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPhxCraftingRecipe* AWSRecipeButton::GetRecipe() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSRecipeButton", "GetRecipe");

	Params::WSRecipeButton_GetRecipe Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSSchematicUploadUI.DoDisplaySchematicAnimation
// (Event, Public, BlueprintEvent)

void AWSSchematicUploadUI::DoDisplaySchematicAnimation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSchematicUploadUI", "DoDisplaySchematicAnimation");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Phoenix.WSSchematicUploadUI.UploadComplete
// (Final, Native, Public, BlueprintCallable)

void AWSSchematicUploadUI::UploadComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSchematicUploadUI", "UploadComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSlider.SetLabel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AWSSlider::SetLabel(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSlider", "SetLabel");

	Params::WSSlider_SetLabel Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSlider.SetSliderValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBroadcast                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSSlider::SetSliderValue(float InValue, bool bBroadcast)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSlider", "SetSliderValue");

	Params::WSSlider_SetSliderValue Parms{};

	Parms.InValue = InValue;
	Parms.bBroadcast = bBroadcast;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSSubtitlesPanelUI.UpdateSubtitleText
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      PrimaryText                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FText&                      SecondaryText                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AWSSubtitlesPanelUI::UpdateSubtitleText(const class FText& PrimaryText, const class FText& SecondaryText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSSubtitlesPanelUI", "UpdateSubtitleText");

	Params::WSSubtitlesPanelUI_UpdateSubtitleText Parms{};

	Parms.PrimaryText = std::move(PrimaryText);
	Parms.SecondaryText = std::move(SecondaryText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSToggle.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInEnabled                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBroadcast                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWSToggle::SetEnabled(bool bInEnabled, bool bBroadcast)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSToggle", "SetEnabled");

	Params::WSToggle_SetEnabled Parms{};

	Parms.bInEnabled = bInEnabled;
	Parms.bBroadcast = bBroadcast;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSToggle.SetLabel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AWSToggle::SetLabel(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSToggle", "SetLabel");

	Params::WSToggle_SetLabel Parms{};

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

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSToggle.ToggleEnabled
// (Final, Native, Public, BlueprintCallable)

void AWSToggle::ToggleEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSToggle", "ToggleEnabled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Phoenix.WSToggle.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AWSToggle::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSToggle", "IsEnabled");

	Params::WSToggle_IsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Phoenix.WSToggleMenu.OnRefreshLabels
// (Event, Protected, BlueprintEvent)

void AWSToggleMenu::OnRefreshLabels()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WSToggleMenu", "OnRefreshLabels");

	UObject::ProcessEvent(Func, nullptr);
}

}

